rumld 0.4.0

data/spec/rumld_node_spec.rb

@@ -0,0 +1,101 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+module Rumld
+  describe 'Node' do
+    before(:each) do
+      @node = Rumld::Node.new(stub('tree', :doc_dir => '/chicken/noodle'), 'Rumld::Node')
+    end
+
+    it 'to_dot for belongs_to relation is blank when there association is empty' do
+      assoc = stub('Assoc', :options => {})
+      @node.send(:to_dot_for_belongs_to, assoc).should be_empty
+    end
+
+    it 'have an empty active record associations if the object does not have associations' do
+      @node.send(:active_record_associations).should == []
+    end
+
+    it 'active record associations reflect on all associations when available' do
+      @node.send(:constant).expects(:reflect_on_all_associations).returns(['One'])
+      @node.send(:active_record_associations).should == ['One']
+    end
+
+    it 'uses constant name to derive the constant' do
+      @node.send(:constant).should == Rumld::Node
+    end
+
+    it 'uses the intersect of rdoc_insepctors all included modules and trees constant names to determine included modules' do
+      @node.tree.expects(:constant_names).returns(['A', 'C', 'A::D'])
+      @node.stubs(:rdoc_inspector).returns(stub('RDocInspector', :all_included_modules => ['A', 'B'] ))
+      @node.included_modules.should == ['A']
+    end
+
+    it 'converts included_modules to_dot' do
+      @node.expects(:included_modules).returns(['NPR', 'Radio'])
+      @node.included_modules_to_dot.should == ['"Rumld::Node" -> "NPR" [style=dotted, arrowhead=empty]', '"Rumld::Node" -> "Radio" [style=dotted, arrowhead=empty]']
+    end
+
+    it 'should use self_to_dot in node_to_dot if there are no children' do
+      @node.expects(:self_to_dot).returns('No Children')
+      @node.expects(:children?).returns(false)
+      @node.node_to_dot.should == 'No Children'
+    end
+
+    it 'should use self_to_dot and children node_to_dot if there are children' do
+      child = Rumld::Node.new(@node.tree, "#{@node.constant_name}::Considered")
+      @node.expects(:self_to_dot).returns('Children')
+      child.expects(:self_to_dot).returns('I am a child')
+      @node.children << child
+
+      @node.node_to_dot.no_whitespace.should match(/#{Regexp.escape(%(subgraphclusterNode{label="Node))}/ )
+
+    end
+
+    it 'should have a self_and_descendants' do
+      child = Rumld::Node.new(@node.tree, "#{@node.constant_name}::Considered")
+      child.expects(:self_and_descendants).returns([child]).at_least(1)
+      @node.children << child
+      @node.self_and_descendants.should == [@node, child] 
+    end
+    
+    it 'by default it should have no children' do
+      @node.children.should == []
+      @node.children?.should == false
+    end
+    
+    it 'should not be a parent of a constant at the same level in the module tree' do
+      @node = Rumld::Node.new(stub('tree', :doc_dir => '/chicken/noodle'), 'Object')
+      @node.should_be_parent_of?('Rumld').should be_false
+    end
+    
+    it 'should be a parent of a constant one level deeper in the module tree' do
+      @node.should_be_parent_of?("#{@node.constant_name}::Considered").should be_true
+    end
+
+    it 'should not be a parent of itself' do
+      @node.should_be_parent_of?("#{@node.constant_name}").should be_false
+    end
+
+    it 'should not be a parent of a constant in the wrong module space' do
+      @node.should_be_parent_of?("Piggly::#{@node.constant_name}::Considered").should be_false
+    end
+
+    it 'should not be a parent of a constant two levels deeper than itself' do
+      @node.should_be_parent_of?("#{@node.constant_name}::Considered::Modules").should be_false
+    end
+    
+    it 'doc_dir is delegated to underlying tree' do
+      @node.tree.doc_dir.should == @node.doc_dir 
+    end
+    
+    it 'constant_is_module is delegated to the underlying rdoc_inspector' do
+      @node.expects(:rdoc_inspector).returns(stub('RDocInspector', :doc_is_for_module? => true))
+      @node.constant_is_module?.should be_true
+    end
+    
+    it 'methods_by_section is delegated to undelrying rdoc_inspector' do
+      @node.expects(:rdoc_inspector).returns(stub('RDocInspector', :methods_by_section => {}))
+      @node.methods_by_section.should == {}
+    end
+  end
+end

data/spec/rumld_rdoc_inspector_spec.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+#class Rumld::RDocInspectorTest < Test::Unit::TestCase
+#
+#  def setup_rdoc
+#    `rdoc #{File.dirname(__FILE__).gsub(' ', '\\ ')}`
+#  end
+#
+#  def teardown
+#    `rm -rf #{File.join(File.dirname(__FILE__), 'doc').gsub(' ', '\\ ')}`
+#  end
+#
+#  def setup
+#    @node = stub('Node', :constant_name => 'Rumld::RDocInspector', :doc_dir => File.join(File.dirname(__FILE__), '..', 'doc'))
+#    @constant_name = 'Rumld::RdocInspectorTest'
+#    @rdoc_inspector = Rumld::RDocInspector.new(@node, @constant_name)
+#  end
+#
+#  def test_doc_file_for
+#    assert_equal 'hello/world/classes/How/Are/You.html', Rumld::RDocInspector.doc_file_for('hello/world', 'How::Are::You')
+#  end
+#
+#  def test_all_included_modules
+#    string = %(
+#    <html><body><div id="includes">
+#          <h3 class="section-bar">Included Modules</h3>
+#
+#          <div id="includes-list">
+#            <span class="include-name">Two::Towers</span>
+#            <span class="include-name"><a href="AccountModel/AccountImport.html">AccountModel::AccountImport</a></span>
+#          </div>
+#        </div></body></html>
+#    )
+#    @rdoc_inspector.expects(:doc).returns(Hpricot( string ))
+#    assert_equal ['Two::Towers', 'AccountModel::AccountImport'], @rdoc_inspector.all_included_modules
+#  end
+#
+#  def test_all_included_modules_should_be_empty_when_no_matching_elements
+#    string = %(
+#    <html><body>
+#        </body></html>
+#    )
+#    @rdoc_inspector.expects(:doc).returns(Hpricot( string ))
+#    assert_equal [], @rdoc_inspector.all_included_modules
+#  end
+#  
+#  def test_doc_is_for_module_when_given_a_module_that_has_been_rdoced
+#    string = '<html><body><div id="classHeader">
+#    <table class="header-table">
+#    <tr class="top-aligned-row">
+#    <td><strong>Module</strong></td>
+#    <td class="class-name-in-header">Rumld::Grapher</td>
+#    </tr>
+#    </table>
+#    </div></body></html>'
+#    @rdoc_inspector.expects(:doc).returns(Hpricot( string ))
+#    assert @rdoc_inspector.doc_is_for_module?
+#  end
+#
+#  def test_doc_is_for_module_when_given_a_class_that_has_been_rdoced
+#    string = '<html><body><div id="classHeader">
+#    <table class="header-table">
+#    <tr class="top-aligned-row">
+#    <td><strong>Class</strong></td>
+#    <td class="class-name-in-header">Rumld::Grapher</td>
+#    </tr>
+#    </table>
+#    </div></body></html>'
+#    @rdoc_inspector.expects(:doc).returns(Hpricot( string ))
+#    assert ! @rdoc_inspector.doc_is_for_module?
+#  end
+#
+#  def test_doc_should_open_the_doc_for_file_and_yield_to_hpricot
+#    setup_rdoc
+#    assert_kind_of Hpricot, @rdoc_inspector.doc
+#  end
+#
+#  def test_doc_file_for_should_delegate_to_class_methods
+#    Rumld::RDocInspector.expects(:doc_file_for).returns('hello')
+#    assert_equal 'hello', @rdoc_inspector.doc_file_for
+#  end
+#
+#  def test_methods_by_section_has_public_instance_methods
+#    setup_rdoc
+#    result = @rdoc_inspector.methods_by_section
+#    assert result.has_key?(:public_instance)
+#    assert result[:public_instance].include?('test_methods_by_section_has_public_instance_methods()')
+#  end
+#
+#end
+#

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+## This file is copied to ~/spec when you run 'ruby script/generate rspec'
+## from the project root directory.
+#ENV["RAILS_ENV"] = "test"
+#require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+#require 'spec/rails'
+#
+#Spec::Runner.configure do |config|
+#  config.use_transactional_fixtures = true
+#  config.use_instantiated_fixtures  = false
+#  config.fixture_path = RAILS_ROOT + '/spec/fixtures'
+#
+#  # You can declare fixtures for each behaviour like this:
+#  #   describe "...." do
+#  #     fixtures :table_a, :table_b
+#  #
+#  # Alternatively, if you prefer to declare them only once, you can
+#  # do so here, like so ...
+#  #
+#  #   config.global_fixtures = :table_a, :table_b
+#  #
+#  # If you declare global fixtures, be aware that they will be declared
+#  # for all of your examples, even those that don't use them.
+#end
+#
+require 'stringio'
+require 'rbconfig'
+
+dir = File.dirname(__FILE__)
+lib_path = File.expand_path("#{dir}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+$_spec_spec = true # Prevents Kernel.exit in various places
+
+require 'rumld'
+gem 'rspec'
+require 'spec'
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end
+
+class << ActiveRecord::Base
+  def columns
+    [:id].collect{|i| ActiveRecord::ConnectionAdapters::Column.new(i, nil)}
+  end
+end
+
+module Abstract; end
+class FirstAbstractUnit < ActiveRecord::Base
+  include Abstract
+  has_many :second_abstract_units
+  has_one :primary_abstract_unit, :class_name => 'SecondAbstractUnit'
+end
+
+class SecondAbstractUnit < ActiveRecord::Base
+  include Abstract
+  
+  belongs_to :first_abstract_unit
+end
+
+class ThirdAbstractUnit < ActiveRecord::Base
+  belongs_to :stuff, :polymorphic => true
+end
+
+class FourthAbstractUnit < ActiveRecord::Base
+  has_many :third_abstract_units, :as => :stuff
+end
+
+class String
+  def no_whitespace
+    gsub(/(\ |\n|\r)/, '')
+  end
+end
+
+class Nil
+  def no_whitespace
+    self
+  end
+end

data/test/rumld_graph_test.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Rumld::GraphTest < Test::Unit::TestCase
+
+  def test_to_dot_delegates_to_tree
+    obj = Rumld::Graph.new('', [],[])
+    obj.expects(:tree).returns(stub('Tree', :to_dot => :to_dot))
+    assert_equal :to_dot, obj.to_dot
+  end
+
+  def test_collect_possible_constant_names
+    assert_equal ["A", "A::B", "A::B::C", "A::B::C::D", "A::B::D", "A::C", "A::C::D", "A::D",
+     "B", "B::C", "B::C::D", "B::D",
+     "C", "C::D",
+     "D"], Rumld::Graph.new(nil, nil, nil).send(:collect_possible_constant_names, ['A', 'B', 'C', 'D'])
+  end
+
+  def test_constants_defined
+    file = <<-EOV
+    class One
+      class Two::Three < One
+        include Eight
+        extend Nine
+        def function(one)
+        end
+      end
+      module Four
+      end
+      class << self
+      end
+
+      class << Five
+      end
+    end
+    EOV
+    assert_equal( ['One', 'Two::Three', 'Four', 'Five'], Rumld::Graph.new(nil, nil, nil).send(:constants_defined, file.split("\n")))
+  end
+  
+  def test_files_to_process_should_use_the_files
+    grapher = Rumld::Graph.new(nil, [File.dirname(__FILE__),File.dirname(__FILE__)], [File.basename(__FILE__)])
+    assert_equal [__FILE__], grapher.send(:files_to_process)
+  end
+  
+end

data/test/rumld_node_test.rb

@@ -0,0 +1,121 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Rumld::NodeTest < Test::Unit::TestCase
+  def setup
+    @node = Rumld::Node.new(stub('tree', :doc_dir => '/chicken/noodle'), 'Rumld::NodeTest')
+  end
+
+  def test_to_dot_for_belongs_to_should_blank
+    assoc = stub('Assoc', :options => {})
+    assert @node.send(:to_dot_for_belongs_to, assoc).empty?
+  end
+
+
+  def test_reflect_on_all_associations_without_an_active_record_object
+    @node = Rumld::Node.new(stub('tree', :doc_dir => '/chicken/noodle'), 'Rumld::Node')
+    assert_equal [], @node.send(:active_record_associations)
+  end
+
+  def test_reflect_on_all_associations_without_an_active_record_object
+    @node = Rumld::Node.new(stub('tree', :doc_dir => '/chicken/noodle'), 'Rumld::Node')
+    @node.send(:constant).expects(:reflect_on_all_associations).returns(['One'])
+    assert_equal ['One'], @node.send(:active_record_associations)
+  end
+
+  def test_constant
+    assert_equal Rumld::Node, Rumld::Node.new(stub('tree', :doc_dir => '/chicken/noodle'), 'Rumld::Node').send(:constant)
+  end
+
+  def test_active_record_associations
+    assert_equal Rumld::Node, Rumld::Node.new(stub('tree', :doc_dir => '/chicken/noodle'), 'Rumld::Node').send(:constant)
+  end
+
+  def test_included_modules_should_be_the_intersect_of_all_included_modules_and_rdocced_modules
+    @node.tree.expects(:constant_names).returns(['A', 'C', 'A::D'])
+    @node.stubs(:rdoc_inspector).returns(stub('RDocInspector', :all_included_modules => ['A', 'B'] ))
+    assert_equal ['A'], @node.included_modules
+  end
+  
+  def test_included_modules_to_dot
+    @node.expects(:included_modules).returns(['NPR', 'Radio'])
+    assert_equal( ['"Rumld::NodeTest" -> "NPR" [style=dotted, arrowhead=empty]', '"Rumld::NodeTest" -> "Radio" [style=dotted, arrowhead=empty]'], @node.included_modules_to_dot)
+  end
+
+  def test_node_to_dot_without_children
+    @node.expects(:self_to_dot).returns('No Children')
+    @node.expects(:children?).returns(false)
+    assert_equal 'No Children', @node.node_to_dot
+  end
+
+  def test_node_to_dot_with_children
+    child = Rumld::Node.new(@node.tree, "#{@node.constant_name}::Considered")
+    @node.expects(:self_to_dot).returns('Children')
+    child.expects(:self_to_dot).returns('I am a child')
+    @node.children << child
+
+    assert_match( /#{Regexp.escape(%(subgraphclusterNodeTest{label="NodeTest))}/, @node.node_to_dot.no_whitespace)
+  end
+  
+  def test_self_and_descendants
+    child = Rumld::Node.new(@node.tree, "#{@node.constant_name}::Considered")
+    child.expects(:self_and_descendants).returns([child]).at_least(1)
+    @node.children << child
+    assert_equal [@node, child], @node.self_and_descendants
+  end
+  
+  def test_children_should_default_to_an_array
+    assert_equal [], @node.children
+  end
+
+  def test_children_empty_means_false_for_children?
+    assert ! @node.children?
+  end
+
+  def test_children_not_empty_means_true_for_children?
+    @node.children << 'Hello'
+    assert @node.children?
+  end
+  
+  def test_constants_should_be_parent_of_regression_prevention_1
+    @node = Rumld::Node.new(stub('tree', :doc_dir => '/chicken/noodle'), 'Object')
+    assert ! @node.should_be_parent_of?('Rumld')
+  end
+  
+  def test_constants_one_module_level_deeper_should_be_child_of_node
+    assert @node.should_be_parent_of?('Rumld::NodeTest::Considered')
+  end
+
+  def test_constants_should_not_be_parents_of_themselves
+    assert ! @node.should_be_parent_of?('Rumld::NodeTest')
+  end
+
+  def test_constants_in_wrong_module_space_should_not_be_child_of_node
+    assert ! @node.should_be_parent_of?('This::Is::Rumld::NodeTest')
+  end
+
+  def test_constants_one_module_level_deeper_in_wrong_module_space_should_not_be_child_of_node
+    assert ! @node.should_be_parent_of?('This::Is::Rumld::NodeTest::Considered')
+  end
+
+  def test_constants_two_module_level_deeper_should_be_child_of_node
+    assert ! @node.should_be_parent_of?('Rumld::NodeTest::Considered::On')
+  end
+  
+  def test_doc_dir_is_delegated_to_nodes_tree
+    assert_equal @node.tree.doc_dir, @node.doc_dir
+  end
+  
+  def test_constant_is_module_is_delegated_to_rdoc_inspector_doc_is_for_module
+    @node.expects(:rdoc_inspector).returns(stub('RDocInspector', :doc_is_for_module? => true))
+    assert_equal true, @node.constant_is_module?
+  end
+  
+  def test_methods_by_section_is_delegated_to_rdoc_inspector
+    @node.expects(:rdoc_inspector).returns(stub('RDocInspector', :methods_by_section => {}))
+    assert_equal( {}, @node.methods_by_section )
+  end
+  
+  def test_format_methods_should_replace_block_bracketes
+    assert_equal "function(self = \\{ :page =\\> 1\\}) \\{ \\|self\\| ... \\}\\l", @node.send(:format_methods, ["function(self = { :page => 1}) { |self| ... }"])
+  end
+end

data/test/rumld_rdoc_inspector_test.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Rumld::RDocInspectorTest < Test::Unit::TestCase
+
+  def setup_rdoc
+    `rdoc #{File.dirname(__FILE__).gsub(' ', '\\ ')}`
+  end
+
+  def teardown
+    `rm -rf #{File.join(File.dirname(__FILE__), 'doc').gsub(' ', '\\ ')}`
+  end
+
+  def setup
+    @node = stub('Node', :constant_name => 'Rumld::RDocInspector', :doc_dir => File.join(File.dirname(__FILE__), '..', 'doc'))
+    @constant_name = 'Rumld::RdocInspectorTest'
+    @rdoc_inspector = Rumld::RDocInspector.new(@node, @constant_name)
+  end
+
+  def test_doc_file_for
+    assert_equal 'hello/world/classes/How/Are/You.html', Rumld::RDocInspector.doc_file_for('hello/world', 'How::Are::You')
+  end
+
+  def test_all_included_modules
+    string = %(
+    <html><body><div id="includes">
+          <h3 class="section-bar">Included Modules</h3>
+
+          <div id="includes-list">
+            <span class="include-name">Two::Towers</span>
+            <span class="include-name"><a href="AccountModel/AccountImport.html">AccountModel::AccountImport</a></span>
+          </div>
+        </div></body></html>
+    )
+    @rdoc_inspector.expects(:doc).returns(Hpricot( string ))
+    assert_equal ['Two::Towers', 'AccountModel::AccountImport'], @rdoc_inspector.all_included_modules
+  end
+
+  def test_all_included_modules_should_be_empty_when_no_matching_elements
+    string = %(
+    <html><body>
+        </body></html>
+    )
+    @rdoc_inspector.expects(:doc).returns(Hpricot( string ))
+    assert_equal [], @rdoc_inspector.all_included_modules
+  end
+  
+  def test_doc_is_for_module_when_given_a_module_that_has_been_rdoced
+    string = '<html><body><div id="classHeader">
+    <table class="header-table">
+    <tr class="top-aligned-row">
+    <td><strong>Module</strong></td>
+    <td class="class-name-in-header">Rumld::Grapher</td>
+    </tr>
+    </table>
+    </div></body></html>'
+    @rdoc_inspector.expects(:doc).returns(Hpricot( string ))
+    assert @rdoc_inspector.doc_is_for_module?
+  end
+
+  def test_doc_is_for_module_when_given_a_class_that_has_been_rdoced
+    string = '<html><body><div id="classHeader">
+    <table class="header-table">
+    <tr class="top-aligned-row">
+    <td><strong>Class</strong></td>
+    <td class="class-name-in-header">Rumld::Grapher</td>
+    </tr>
+    </table>
+    </div></body></html>'
+    @rdoc_inspector.expects(:doc).returns(Hpricot( string ))
+    assert ! @rdoc_inspector.doc_is_for_module?
+  end
+
+  def test_doc_should_open_the_doc_for_file_and_yield_to_hpricot
+    setup_rdoc
+    assert_kind_of Hpricot, @rdoc_inspector.doc
+  end
+
+  def test_doc_file_for_should_delegate_to_class_methods
+    Rumld::RDocInspector.expects(:doc_file_for).returns('hello')
+    assert_equal 'hello', @rdoc_inspector.doc_file_for
+  end
+
+  def test_methods_by_section_has_public_instance_methods
+    setup_rdoc
+    result = @rdoc_inspector.methods_by_section
+    assert result.has_key?(:public_instance)
+    assert result[:public_instance].include?('test_methods_by_section_has_public_instance_methods()')
+  end
+
+end

data/test/rumld_tree_test.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Rumld::TreeTest < Test::Unit::TestCase
+  def setup
+    @tree = Rumld::Tree.new(nil, [])
+  end
+  
+  def test_doc_dir_is_delegated_graph
+    @tree.expects(:graph).returns(stub('Graph', :doc_dir => :doc_dir))
+    assert_equal :doc_dir, @tree.doc_dir
+  end
+  
+  def test_build_nodes_with_multi_level_constant_names
+    @tree = Rumld::Tree.new(nil, ['A', 'A::B', 'A::B::C'])
+    assert_equal ['A'], @tree.nodes.collect{|n| n.constant_name}
+  end
+
+  def test_build_nodes_with_single_level_constant_names
+    @tree = Rumld::Tree.new(nil, ['A', 'A::B'])
+    assert_equal ['A'], @tree.nodes.collect{|n| n.constant_name}
+  end
+  
+  def test_all_nodes
+    @tree = Rumld::Tree.new(nil, ['A', 'A::B'])
+    assert_equal ['A', 'A::B'], @tree.all_nodes.collect{|n| n.constant_name}
+  end
+  
+  def test_node_for_should_return_a_node_that_matches_the_given_constant
+    node = stub("Node", :constant => self.class)
+    @tree.expects(:all_nodes).returns([node])
+    assert_equal node, @tree.node_for(self.class)
+  end
+
+  def test_node_for_should_return_a_node_that_matches_the_given_constant_name
+    node = stub("Node", :constant => self.class, :constant_name => "Awesome")
+    @tree.expects(:all_nodes).returns([node])
+    assert_equal node, @tree.node_for('Awesome')
+  end
+  
+  def test_inheritence_edge_to_dot
+    node = stub("Node", :inheritence_edge_to_dot => ['hello world'])
+    @tree.expects(:all_nodes).returns([node])
+    assert_equal 'hello world', @tree.send(:draw_inheritence_edges)
+  end
+  
+  def test_to_dot_calls_draw_nodes_and_draw_included_modules
+    @tree.expects(:draw_nodes).returns('Draw Nodes')
+    @tree.expects(:draw_included_modules).returns('Draw Included Modules')
+    @tree.expects(:draw_associations).returns('Draw Associations')
+    @tree.expects(:draw_inheritence_edges).returns('Draw Inheritence Edges')
+    assert_equal( %(digraph uml_diagram {
+      graph[overlap=false, splines=true]
+      Draw Nodes
+      Draw Included Modules
+      Draw Associations
+      Draw Inheritence Edges
+    }).no_whitespace, @tree.to_dot.no_whitespace)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '../lib'))
+require "test/unit"
+require 'rumld'
+
+class String
+  def no_whitespace
+    gsub(/(\ |\n|\r)/, '')
+  end
+end
+
+class Nil
+  def no_whitespace
+    self
+  end
+end