DepGraph 0.8.0

data/spec/dependable_filter_manager_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require 'rubygems'
+require 'spec'
+require 'dependable_filter_manager'
+include DepGraph
+
+describe DependableFilterManager do
+  
+  it "should return the available filter types" do
+    dependency_types_in_file = YAML.load_file(DependableFilterManager.dependency_types_file).map do |filter_type_in_file, _| 
+      filter_type_in_file
+    end
+    
+    dependency_types_in_file.should == dependency_types.map {|filter_type| filter_type.to_s}
+  end
+  
+  it "should use default values if the specified filter type is not found" do
+    dependable_filter_manager = DependableFilterManager.new non_existent_filter_type
+    
+    dependable_filter_manager.dependable_regexp.should == /.+/
+    dependable_filter_manager.dependable_regexp_capture_group_index.should == 0
+    dependable_filter_manager.file_name_pattern.should == '*'
+  end
+
+
+  sample_contents = {
+    :ruby_requires => {:content => ['require "something/dependency"',
+                           "  require   'something/dependency.rb'"],
+              :file_pattern => '*.rb'},
+            
+    :csproj => {:content => ['sdff "directory\\dependency.csproj"hyhyhy',
+                             'asdfffd"directory\\anotherdir\\dependency.dll" gfgfgg'],
+                :file_pattern => '*.csproj'}
+  }
+
+  dependency_types.each do |filter_type|
+    it "should have a #{filter_type} filter type" do
+      dependable_filter_manager = DependableFilterManager.new filter_type
+    
+      capture_index = dependable_filter_manager.dependable_regexp_capture_group_index
+      sample_contents[filter_type][:content].each do |sample_dependency|
+          dependable_filter_manager.dependable_regexp.match(sample_dependency).captures[capture_index].should == 'dependency'
+      end
+      dependable_filter_manager.file_name_pattern.should == sample_contents[filter_type][:file_pattern]
+    end
+  end
+end
+

data/spec/dependent_spec.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require 'stringio'
+require 'dependent' 
+require 'rubygems'
+require 'spec'
+include DepGraph
+
+describe Dependent do
+  it 'should not accept empty uris in the constructor' do
+    lambda{Dependent.new('')}.should raise_error
+  end
+  
+  it 'should have a non empty name' do
+    dependent = Dependent.new('a')
+    dependent.name.should_not be_empty
+  end
+  
+  it 'should have the name of the file specified in the constructor excluding the extension' do
+    dependent = Dependent.new('/directory1/directory2/file.name.ext')
+    dependent.name.should == 'file.name'
+  end
+  
+  it 'should be equal to another dependent with the same name' do
+    dependent1 = Dependent.new('abc')
+    dependent2 = Dependent.new('abc')
+    dependent3 = Dependent.new('abd')
+    
+    dependent1.should == dependent2
+    dependent1.should be_eql(dependent2)
+
+    dependent1.should_not == dependent3
+    dependent1.should_not be_eql(dependent3)
+    
+    dependent2.should_not == dependent3
+    dependent2.should_not be_eql(dependent3)
+  end
+  
+  it 'should allow setting dependent dependents' do
+    dependent = Dependent.new('a')
+    dependent.depends_on('b')
+    
+    dependent.dependencies.size.should == 1
+  end
+  
+  it 'should allow querying for a dependent dependent' do
+    dependent = Dependent.new('a')
+    dependent.depends_on('b')
+    
+    dependent.depends_on?('b').should be_true
+    dependent.depends_on?('c').should be_false
+  end
+  
+  it 'should be able to get the dependencies to csproj and dll files from a string' do
+    dependent = Dependent.new('a', :csproj)
+    dependencies_string = 'from this string the dependable to "\\a.dir\\dependent1.csproj", \n"\\tgg.hyhy\\dependent2.dll" and "dependent3.csproj" should be found'
+    
+    dependent.load_dependencies_from_string(dependencies_string)
+
+    dependent.dependencies.should == ["dependent1", "dependent2", "dependent3"]
+  end
+  
+  it 'should be able to use a custom regexp filter to get the dependent dependencies from a string' do
+    dependent = Dependent.new('a')
+    dependencies_string = 'from this string the dependable to dependent.csproj \n and dependent1.dll should be found'
+    dependent.dependable_filter = /\s([^\s]+)\.(csproj|dll)[^\w]/
+    dependent.dependable_filter_capture_group_index = 0
+    
+    dependent.load_dependencies_from_string(dependencies_string)
+
+    dependent.dependencies.should == ["dependent", "dependent1"]
+  end
+  
+  it 'should be able to select the capture group that must be used in the dependable custom regexp filter' do
+    dependent = Dependent.new('a')
+    dependencies_string = 'from this string the dependable to prefix.dependent.csproj \n and prefix.dependent1.dll should be found'
+    dependent.dependable_filter = /\s(prefix\.)([^\s]+)\.(csproj|dll)[^\w]/
+    dependent.dependable_filter_capture_group_index = 1 
+    
+    dependent.load_dependencies_from_string(dependencies_string)
+
+    dependent.dependencies.should == ["dependent", "dependent1"]
+  end
+  
+  it 'should ignore repeated dependencies in the string' do
+    dependent = Dependent.new('a', :csproj)
+    dependencies_string = 'this string has only one dependable that is repeated 3 times: "\\a.dir\\dependent.csproj", \n"\\tgg.hyhy\\dependent.dll" and "dependent.csproj"'
+    
+    dependent.load_dependencies_from_string(dependencies_string)
+
+    dependent.dependencies.should == ["dependent"]
+  end
+  
+  it 'should ignore the capture group index if the dependable filter regexp has no capture groups' do
+    dependent = Dependent.new('a')
+    dependent.dependable_filter = /dep[0-9]/
+    dependent.dependable_filter_capture_group_index = 1 
+    
+    dependent.load_dependencies_from_string('dep1 is in the first line \n in the second dep2')
+    
+    dependent.dependencies.size.should == 2
+  end
+end

data/spec/depgraph_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require 'rubygems'
+gem 'filetesthelper'
+require 'filetesthelper'
+
+include FileTestHelper
+
+default_graph_file = 'dependency_graph.png'
+tool_name = 'depgraph'
+tool_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', tool_name))
+
+describe "#{tool_name} (integration tests)" do
+ 
+  test_data = {
+    :csproj => {'proj1.csproj' => '"proj2.csproj"', 'proj2.csproj' => '"proj1.csproj"'},
+    :ruby_requires => {'rubyfile1.rb' => 'require "rubyfile2"', 'rubyfile2.rb' => 'require "rubyfile3"'},
+  }
+
+  dependency_types.each do |filter_type|
+    it "should create a file from the #{filter_type} files found in the current directory" do
+      test_files = test_data[filter_type]
+      with_files(test_files) do
+        system "ruby #{tool_path} -type #{filter_type}"
+        
+        non_empty_file_created(default_graph_file).should be_true
+      end
+    end
+  end
+  
+  two_files_with_one_dependency_from_file1_to_file2 = {'file1.csproj' => '"file2.csproj"', 'file2.csproj' => ''}
+  it 'should not create a file when the "-from" filter does not find matches' do
+    with_files(two_files_with_one_dependency_from_file1_to_file2) do
+      system "ruby #{tool_path} -type csproj -from file2"
+      
+      File.exist?(default_graph_file).should be_false
+    end
+  end
+  
+  it 'should create a file when the "-from" filter finds matches' do
+    with_files(two_files_with_one_dependency_from_file1_to_file2) do
+      system "ruby #{tool_path} -type csproj -from file1"
+      
+      File.exist?(default_graph_file).should be_true
+    end
+  end
+  
+  it 'should not create a file when the "-to" filter does not find matches' do
+    with_files(two_files_with_one_dependency_from_file1_to_file2) do
+      system "ruby #{tool_path} -type csproj -to file1"
+      
+      File.exist?(default_graph_file).should be_false
+    end
+  end
+  
+  it 'should create a file when the "-to" filter finds matches' do
+    with_files(two_files_with_one_dependency_from_file1_to_file2) do
+      system "ruby #{tool_path} -type csproj -to file2"
+      
+      File.exist?(default_graph_file).should be_true
+    end
+  end
+end
+
+

data/spec/file_system_dependent_finder_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require 'file_system_dependent_finder'
+require 'rubygems'
+gem 'filetesthelper'
+require 'filetesthelper'
+require 'spec'
+
+include FileTestHelper
+include DepGraph
+
+describe FileSystemDependentFinder, '(integration tests)' do
+  it 'should search only in the specified directories' do
+      with_files('good1/file1' => '', 'good2/file2' => '', 'bad/file3' => '') do
+        dependent_finder = FileSystemDependentFinder.new(non_existent_filter_type)
+        dependent_finder.dirs = ['good1', 'good2']
+        
+        dependents = dependent_finder.get_dependents
+        dependents.should == ['file1', 'file2']
+      end
+  end
+end
+
+#To setup the test files for each filter type, include three sample dependent files
+#and make the first file, named 'a' depend on the next two, named 'b' and 'c'
+test_set = {
+  :ruby_requires => {'a.rb' => 'require "b"\nrequire "c"', 'dir/b.rb' => '', 'dir/c.rb' => '', 'not_a_ruby_file' => ''},
+  :csproj => {'a.csproj' => '"b.csproj"\n"c.csproj"', 'dir/b.csproj' => '', 'dir/c.csproj' => '', 'not_a_csproj_file' => ''}
+}
+  
+dependency_types.each do |filter_type|
+  test_files = test_set[filter_type]
+  
+  describe FileSystemDependentFinder, "for #{filter_type.to_s} (integration tests)" do
+    it "should find the correct number of dependents" do
+      with_files(test_files) do
+        dependents = FileSystemDependentFinder.new(filter_type).get_dependents
+        dependents.should == ['a', 'b', 'c']
+      end
+    end
+    it "should correctly find the dependencies from each file" do
+      with_files(test_files) do
+        dependent = FileSystemDependentFinder.new(filter_type).get_dependents[0]
+        dependent.should_not be_nil
+        dependent.dependencies.should == ['b', 'c']
+      end
+    end
+  end
+end

data/spec/graph_creator_spec.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require 'graph_creator'
+require 'rubygems'
+gem 'filetesthelper'
+require 'spec'
+require 'filetesthelper'
+include DepGraph
+include FileTestHelper
+  
+describe GraphCreator do
+  it 'should not create a file if the graph is empty' do
+    create_graph_creator_with_no_dependents.create_image.should be_false
+  end
+
+  it 'should return a nil graph if an empty set of dependents is specified' do
+    create_graph_creator_with_no_dependents.create_graph.should == nil
+  end
+  
+  it 'should return a nil graph if only one dependent is specified' do
+    create_graph_creator_with_only_one_dependent.create_graph.should == nil
+  end
+  
+  it 'should return a nil graph if all dependents specified are equal' do
+    create_graph_creator_with_three_dependents_that_are_equal.create_graph.should == nil
+  end
+  
+  it 'should return a graph with 2 nodes and no edges if 2 dependents with no dependencies are specified' do
+    graph = create_graph_creator_with_two_dependents_and_no_dependencies.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 0
+  end
+  
+  it 'should ignore dependencies to non existent dependents' do
+    graph = create_graph_creator_with_two_nodes_and_one_orphan_dependency.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 0
+  end
+  
+  it 'should return a graph with one edge if two dependents with one dependable are specified' do
+    graph = create_graph_creator_with_two_nodes_and_one_dependency.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+  end
+  
+  it 'should be possible to filter dependents with a regular expression' do
+    graph_creator = create_dependency_chain_graph_creator('node1', 'node2', 'node3', 'node4')
+    graph_creator.from = 'e2$'
+    graph = graph_creator.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+    graph.has_node?('node2').should be_true
+    graph.has_node?('node3').should be_true
+    graph.has_edge?('node2', 'node3').should be_true
+  end
+  
+  it 'should be possible to filter dependables with a regular expression' do
+    graph_creator = create_dependency_chain_graph_creator('node1', 'node2', 'node3', 'node4')
+    graph_creator.to = 'e4$'
+    graph = graph_creator.create_graph
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+    graph.has_node?('node3').should be_true
+    graph.has_node?('node4').should be_true
+    graph.has_edge?('node3', 'node4').should be_true
+  end
+
+  
+  invalid_graph_creators.each do |invalid_graph_creator_description, invalid_graph_creator|  
+    it "should return false when trying to create an image from a #{invalid_graph_creator_description}" do
+      invalid_graph_creator.graph_class = NoOutputGraph
+      invalid_graph_creator.create_image('graph.png').should be_false
+    end
+  end
+end
+
+test_data = {
+  :csproj => {'file1.csproj'=>'"file2.csproj"', 'dir/file2.csproj'=>'"file1.csproj"' },
+  :ruby_requires => {'file1.rb'=>'require "file2"', 'dir/file2.rb'=>'require "file1"' }
+}
+
+describe GraphCreator, '(integration tests)' do
+  dependency_types.each do |filter_type|
+    it "should create a png image from the #{filter_type} dependencies found in the current directory tree" do
+      with_files(test_data[filter_type]) do
+        GraphCreator.new(filter_type).create_image('test.png')
+      
+        non_empty_file_created('test.png').should be_true
+      end
+    end
+  end
+end  
+
+
+
+
+
+
+

data/spec/graph_spec.rb

@@ -0,0 +1,120 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require 'graph'
+require 'rubygems'
+gem 'filetesthelper'
+require 'spec'
+require 'filetesthelper'
+include FileTestHelper
+include DepGraph
+
+def create_empty_graph
+  Graph.new
+end
+
+def create_graph_with_2_nodes_and_1_edge
+  graph = create_empty_graph
+  graph.add_node('node 1')
+  graph.add_node('node 2')
+  graph.add_edge('node 1', 'node 2')
+  return graph
+end
+
+def create_graph_with_2_nodes_and_0_edges
+  graph = create_empty_graph
+  graph.add_node('node 1')
+  graph.add_node('node 2')
+  return graph
+end
+
+def no_output_generation
+  lambda {true}
+end
+
+describe Graph do
+  
+  it "should start with no nodes" do
+    create_empty_graph.node_count.should == 0
+  end
+  
+  it "should be possible to add nodes" do
+    graph = create_graph_with_2_nodes_and_0_edges
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 0
+  end
+  
+  it "should not be allowed to add a node without a name" do
+    lambda {create_empty_graph.add_node('')}.should raise_error
+  end
+  
+  it "should start with no edges" do
+    create_empty_graph.edge_count.should == 0
+  end
+  
+  it "should be possible to add an edge" do
+    graph = create_graph_with_2_nodes_and_1_edge
+    
+    graph.node_count.should == 2
+    graph.edge_count.should == 1
+  end
+  
+  it "can be reset" do
+    graph = create_graph_with_2_nodes_and_1_edge
+    
+    graph.reset
+    graph.node_count.should == 0
+    graph.edge_count.should == 0
+  end
+    
+  it "should not be allowed to add edges between non existent nodes" do
+    lambda {create_empty_graph.add_edge('no node 1', 'no node 2')}.should raise_error
+  end
+  
+  it "should return true when a new image file is created" do
+    graph = create_graph_with_2_nodes_and_1_edge    
+    graph.output_generation = no_output_generation
+    graph.create_image('graph.png').should be_true
+  end
+  
+  it "should return false when trying to create an empty graph" do
+    graph = create_empty_graph
+    graph.output_generation = no_output_generation
+    graph.create_image('graph.png').should be_false
+  end
+end
+
+describe Graph, '(integration tests)' do
+  it "should create a file with the graph image" do
+    with_files do
+      graph = create_graph_with_2_nodes_and_1_edge    
+      graph.create_image('graph.png')
+
+      non_empty_file_created('graph.png').should be_true
+    end
+  end
+  
+  it "should not create an image file from an empty graph" do
+    with_files do
+      create_empty_graph.create_image('graph.png')
+      non_empty_file_created('graph.png').should be_false
+    end
+  end
+  
+  it "should not create an image file from a graph with no edges" do
+    with_files do
+      create_graph_with_2_nodes_and_0_edges.create_image('graph.png')
+      
+      non_empty_file_created('graph.png').should be_false
+    end
+  end
+  
+  it 'can change output generation behaviour'do
+    graph = create_graph_with_2_nodes_and_1_edge
+    graph.output_generation = no_output_generation
+    with_files do
+      graph.create_image('test.png')
+      File.exist?('test.png').should be_false
+    end
+  end
+end
+

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--format
+specdoc
+--format
+html:specs.html
+--timeout
+20
+--diff

data/spec/spec_helper.rb

@@ -0,0 +1,123 @@
+require 'enumerator'
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+dir = File.expand_path(File.dirname(__FILE__)) 
+$LOAD_PATH.unshift("#{dir}/") 
+$LOAD_PATH.unshift("#{dir}/../lib") 
+
+require 'dependable_filter_manager'
+require 'graph'
+def dependency_types
+  DepGraph::DependableFilterManager.types
+end
+
+def non_empty_file_created(file_name)
+  File.exist?(file_name) and File.size(file_name) > 0
+end
+
+def non_existent_filter_type
+  DependableFilterManager.types.join + 'thisdoesntexist'
+end
+
+########## Stubs ###########
+class MockDependentFinder
+  def initialize(dependents)
+    @dependents = dependents
+  end
+    
+  def get_dependents
+    @dependents
+  end
+end
+  
+class NoOutputGraph < DepGraph::Graph
+  def initialize
+    super
+    output_generation = lambda { true }
+  end
+end
+
+
+########## graph creator tests helper methods ###########
+def create_graph_creator_with_no_dependents
+  graph_creator = GraphCreator.new
+  graph_creator.dependent_finder = MockDependentFinder.new([])
+  
+  return graph_creator
+end
+
+def create_graph_creator_with_only_one_dependent
+  graph_creator = GraphCreator.new
+  graph_creator.dependent_finder = MockDependentFinder.new([Dependent.new('dependent/path')])  
+  
+  return graph_creator
+end
+
+def create_graph_creator_with_three_dependents_that_are_equal
+  dependent1 = Dependent.new('directory/path')
+  dependent2 = Dependent.new('directory/path')
+  dependent3 = Dependent.new('directory/anotherdir/path')
+    
+  graph_creator = GraphCreator.new    
+  graph_creator.dependent_finder = MockDependentFinder.new([dependent1, dependent2, dependent3])
+
+  return graph_creator
+end
+
+def create_graph_creator_with_two_dependents_and_no_dependencies
+  dependent1 = Dependent.new('dependent1/path1')
+  dependent2 = Dependent.new('dependent2/path2')
+    
+  graph_creator = GraphCreator.new   
+  graph_creator.dependent_finder = MockDependentFinder.new([dependent1, dependent2])
+
+  return graph_creator
+end
+
+def create_dependency_chain_graph_creator(*nodes)
+  dependents = []
+
+  nodes.each do |node|
+    dependents << Dependent.new(node)
+  end
+
+  dependents.each_cons(2) do |dependent, dependable|
+    dependent.depends_on(dependable)
+  end
+    
+  graph_creator = GraphCreator.new(:none)    
+  graph_creator.dependent_finder = MockDependentFinder.new(dependents)
+  
+  return graph_creator
+end
+
+def create_graph_creator_with_two_nodes_and_one_dependency
+  return create_dependency_chain_graph_creator('dependent1/path1.csproj', 'dependent2/path2.dll')
+end
+
+def create_graph_creator_with_two_nodes_and_one_orphan_dependency
+  dependent1 = Dependent.new('file1.csproj')
+  dependent2 = Dependent.new('file2.csproj')
+  dependent2.depends_on('file3')
+    
+  graph_creator = GraphCreator.new(:none)    
+  graph_creator.dependent_finder = MockDependentFinder.new([dependent1, dependent2])
+  
+  return graph_creator
+end
+
+def invalid_graph_creators
+  {
+    'graph creator with no dependents' => create_graph_creator_with_no_dependents,
+    'graph creator with only one dependent' => create_graph_creator_with_only_one_dependent,
+    'graph creator with three dependents that are equal' => create_graph_creator_with_three_dependents_that_are_equal,
+    'graph creator with an orphan depencency' => create_graph_creator_with_two_nodes_and_one_orphan_dependency
+  }
+end
+

data/tasks/deployment.rake

@@ -0,0 +1,34 @@
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:spec, :website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
+task :install_gem_no_doc => [:clean, :package] do
+  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
+end
+
+namespace :manifest do
+  desc 'Recreate Manifest.txt to include ALL files'
+  task :refresh do
+    `rake check_manifest | patch -p0 > Manifest.txt`
+  end
+end

data/tasks/environment.rake

@@ -0,0 +1,7 @@
+task :ruby_env do
+  RUBY_APP = if RUBY_PLATFORM =~ /java/
+    "jruby"
+  else
+    "ruby"
+  end unless defined? RUBY_APP
+end

data/tasks/rspec.rake

@@ -0,0 +1,23 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/*_spec.rb']
+  t.rcov = true
+  t.rcov_opts = ['--text-summary']
+end