rdoc 2.3.0 → 2.4.0

data/lib/rdoc/single_class.rb

@@ -0,0 +1,8 @@
+require 'rdoc/class_module'
+
+##
+# A singleton class
+
+class RDoc::SingleClass < RDoc::ClassModule
+end
+

data/lib/rdoc/top_level.rb

@@ -0,0 +1,232 @@
+require 'thread'
+require 'rdoc/context'
+
+##
+# A TopLevel context is a representation of the contents of a single file
+
+class RDoc::TopLevel < RDoc::Context
+
+  ##
+  # This TopLevel's File::Stat struct
+
+  attr_accessor :file_stat
+
+  ##
+  # Relative name of this file
+
+  attr_accessor :relative_name
+
+  ##
+  # Absolute name of this file
+
+  attr_accessor :absolute_name
+
+  attr_accessor :diagram
+
+  ##
+  # The parser that processed this file
+
+  attr_accessor :parser
+
+  ##
+  # Returns all classes and modules discovered by RDoc
+
+  def self.all_classes_and_modules
+    classes_hash.values + modules_hash.values
+  end
+
+  ##
+  # Returns all classes discovered by RDoc
+
+  def self.classes
+    classes_hash.values
+  end
+
+  ##
+  # Hash of all classes known to RDoc
+
+  def self.classes_hash
+    @all_classes
+  end
+
+  ##
+  # All TopLevels known to RDoc
+
+  def self.files
+    @all_files.values
+  end
+
+  ##
+  # Hash of all files known to RDoc
+
+  def self.files_hash
+    @all_files
+  end
+
+  ##
+  # Finds the class with +name+ in all discovered classes
+
+  def self.find_class_named(name)
+    @lock.synchronize do
+      classes_hash.values.find do |c|
+        c.find_class_named name
+      end
+    end
+  end
+
+  ##
+  # Finds the file with +name+ in all discovered files
+
+  def self.find_file_named(name)
+    @lock.synchronize do
+      @all_files[name]
+    end
+  end
+
+  ##
+  # Finds the module with +name+ in all discovered modules
+
+  def self.find_module_named(name)
+    @lock.synchronize do
+      modules_hash.values.find do |c|
+        c.find_module_named name
+      end
+    end
+  end
+
+  @lock = Mutex.new
+
+  ##
+  # Lock for global class, module and file stores
+
+  def self.lock
+    @lock
+  end
+
+  ##
+  # Returns all modules discovered by RDoc
+
+  def self.modules
+    modules_hash.values
+  end
+
+  ##
+  # Hash of all modules known to RDoc
+
+  def self.modules_hash
+    @all_modules
+  end
+
+  ##
+  # Empties RDoc of stored class, module and file information
+
+  def self.reset
+    @lock.synchronize do
+      @all_classes = {}
+      @all_modules = {}
+      @all_files   = {}
+    end
+  end
+
+  reset
+
+  ##
+  # Creates a new TopLevel for +file_name+
+
+  def initialize(file_name)
+    super()
+    @name = nil
+    @relative_name = file_name
+    @absolute_name = file_name
+    @file_stat     = File.stat(file_name) rescue nil # HACK for testing
+    @diagram       = nil
+    @parser        = nil
+
+    RDoc::TopLevel.lock.synchronize do
+      RDoc::TopLevel.files_hash[file_name] = self
+    end
+  end
+
+  ##
+  # Base name of this file
+
+  def base_name
+    File.basename @absolute_name
+  end
+
+  ##
+  # Find class or module named +symbol+ in all discovered classes and
+  # modules
+
+  def find_class_or_module_named(symbol)
+    RDoc::TopLevel.classes_hash.each_value do |c|
+      return c if c.full_name == symbol
+    end
+
+    RDoc::TopLevel.modules_hash.each_value do |m|
+      return m if m.full_name == symbol
+    end
+
+    nil
+  end
+
+  ##
+  # Finds a class or module named +symbol+
+
+  def find_local_symbol(symbol)
+    find_class_or_module_named(symbol) || super
+  end
+
+  ##
+  # Finds a module or class with +name+
+
+  def find_module_named(name)
+    find_class_or_module_named(name) || find_enclosing_module_named(name)
+  end
+
+  ##
+  # The name of this file
+
+  def full_name
+    @relative_name
+  end
+
+  ##
+  # URL for this with a +prefix+
+
+  def http_url(prefix)
+    path = [prefix, @relative_name.tr('.', '_')]
+
+    File.join(*path.compact) + '.html'
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %p modules: %p classes: %p>" % [
+      self.class, object_id,
+      base_name,
+      @modules.map { |n,m| m },
+      @classes.map { |n,c| c }
+    ]
+  end
+
+  ##
+  # Date this file was last modified, if known
+
+  def last_modified
+    @file_stat ? file_stat.mtime.to_s : 'Unknown'
+  end
+
+  ##
+  # Base name of this file
+
+  alias name base_name
+
+  ##
+  # Path to this file
+
+  def path
+    http_url RDoc::RDoc.current.generator.file_dir
+  end
+
+end
+

data/test/test_rdoc_any_method.rb

@@ -0,0 +1,10 @@
+require 'test/xref_test_case'
+
+class RDocAnyMethodTest < XrefTestCase
+
+  def test_full_name
+    assert_equal 'C1::m', @c1.method_list.first.full_name
+  end
+
+end
+

data/test/test_rdoc_code_object.rb

@@ -0,0 +1,80 @@
+require 'rubygems'
+require 'minitest/unit'
+require 'test/xref_test_case'
+require 'rdoc/code_object'
+
+class TestRDocCodeObject < XrefTestCase
+
+  def setup
+    super
+
+    @co = RDoc::CodeObject.new
+  end
+
+  def test_initialize
+    assert @co.document_self, 'document_self'
+    assert @co.document_children, 'document_children'
+    refute @co.force_documentation, 'force_documentation'
+    refute @co.done_documenting, 'done_documenting'
+    assert_equal nil, @co.comment, 'comment is nil'
+  end
+
+  def test_comment_equals
+    @co.comment = ''
+
+    assert_equal nil, @co.comment
+
+    @co.comment = 'I am a comment'
+
+    assert_equal 'I am a comment', @co.comment
+  end
+
+  def test_document_children_equals
+    @co.document_children = false
+    refute @co.document_children
+
+    @c2.document_children = false
+    assert_empty @c2.classes
+  end
+
+  def test_document_self_equals
+    @co.document_self = false
+    refute @co.document_self
+
+    @c1.document_self = false
+    assert_empty @c1.method_list
+  end
+
+  def test_parent_file_name
+    assert_equal '(unknown)', @co.parent_file_name
+    assert_equal 'xref_data.rb', @c1.parent_file_name
+  end
+
+  def test_parent_name
+    assert_equal '(unknown)', @co.parent_name
+    assert_equal 'xref_data.rb', @c1.parent_name
+    assert_equal 'C2', @c2_c3.parent_name
+  end
+
+  def test_start_doc
+    @co.document_self = false
+    @co.document_children = false
+
+    @co.start_doc
+
+    assert @co.document_self
+    assert @co.document_children
+  end
+
+  def test_stop_doc
+    @co.document_self = true
+    @co.document_children = true
+
+    @co.stop_doc
+
+    refute @co.document_self
+    refute @co.document_children
+  end
+
+end
+

data/test/test_rdoc_constant.rb

@@ -0,0 +1,15 @@
+require 'test/xref_test_case'
+
+class TestRDocConstant < XrefTestCase
+
+  def setup
+    super
+
+    @const = @c1.constants.first
+  end
+
+  def test_path
+    assert_equal 'C1.html#CONST', @const.path
+  end
+
+end

data/test/test_rdoc_context.rb

@@ -0,0 +1,250 @@
+require 'rubygems'
+require 'minitest/unit'
+require 'test/xref_test_case'
+
+class TestRDocContext < XrefTestCase
+
+  def setup
+    super
+
+    @context = RDoc::Context.new
+  end
+
+  def test_initialize
+    assert_empty @context.in_files
+    assert_equal 'unknown', @context.name
+    assert_equal '', @context.comment
+    assert_equal nil, @context.parent
+    assert_equal :public, @context.visibility
+    assert_equal 1, @context.sections.length
+
+    assert_empty @context.classes_hash
+    assert_empty @context.modules_hash
+
+    assert_empty @context.method_list
+    assert_empty @context.attributes
+    assert_empty @context.aliases
+    assert_empty @context.requires
+    assert_empty @context.includes
+    assert_empty @context.constants
+  end
+
+  def test_add_alias
+    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
+
+    @context.add_alias as
+
+    assert_equal [as], @context.aliases
+    assert_equal [as], @context.unmatched_alias_lists['old_name']
+  end
+
+  def test_add_alias_method
+    meth = RDoc::AnyMethod.new nil, 'old_name'
+    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
+    as.parent = @context
+
+    @context.add_method meth
+    @context.add_alias as
+
+    assert_empty @context.aliases
+    assert_empty @context.unmatched_alias_lists
+    assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
+  end
+
+  def test_add_class
+    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
+
+    assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass'
+    assert_includes RDoc::TopLevel.classes.map { |k| k.full_name }, 'C1::Klass'
+  end
+
+  def test_add_class_upgrade
+    @c1.add_module RDoc::NormalModule, 'Klass'
+    @c1.add_class RDoc::NormalClass, 'Klass', nil
+
+    assert_includes @c1.classes.map { |k| k.full_name }, 'C1::Klass',
+                    'c1 classes'
+    refute_includes @c1.modules.map { |k| k.full_name }, 'C1::Klass',
+                    'c1 modules'
+
+    assert_includes RDoc::TopLevel.classes.map { |k| k.full_name }, 'C1::Klass',
+                    'TopLevel classes'
+    refute_includes RDoc::TopLevel.modules.map { |k| k.full_name }, 'C1::Klass',
+                    'TopLevel modules'
+  end
+
+  def test_add_constant
+    const = RDoc::Constant.new 'NAME', 'value', 'comment'
+    @context.add_constant const
+
+    assert_equal [const], @context.constants
+  end
+
+  def test_add_include
+    incl = RDoc::Include.new 'Name', 'comment'
+    @context.add_include incl
+
+    assert_equal [incl], @context.includes
+  end
+
+  def test_add_method
+    meth = RDoc::AnyMethod.new nil, 'old_name'
+    meth.visibility = nil
+
+    @context.add_method meth
+
+    assert_equal [meth], @context.method_list
+    assert_equal :public, meth.visibility
+  end
+
+  def test_add_method_alias
+    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
+    meth = RDoc::AnyMethod.new nil, 'old_name'
+
+    @context.add_alias as
+    refute_empty @context.aliases
+
+    @context.add_method meth
+
+    assert_empty @context.aliases
+    assert_empty @context.unmatched_alias_lists
+    assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
+  end
+
+  def test_add_module
+    @c1.add_module RDoc::NormalModule, 'Mod'
+
+    assert_includes @c1.modules.map { |m| m.full_name }, 'C1::Mod'
+  end
+
+  def test_add_module_class
+    k = @c1.add_class RDoc::NormalClass, 'Klass', nil
+    m = @c1.add_module RDoc::NormalModule, 'Klass'
+
+    assert_equal k, m, 'returns class'
+    assert_empty @c1.modules
+  end
+
+  def test_add_require
+    req = RDoc::Require.new 'require', 'comment'
+    @c1.add_require req
+
+    assert_empty @c1.requires
+    assert_includes @c1.top_level.requires, req
+  end
+
+  def test_add_to
+    incl = RDoc::Include.new 'Name', 'comment'
+    arr = []
+    @context.add_to arr, incl
+
+    assert_includes arr, incl
+    assert_equal @context, incl.parent
+    assert_equal @context.current_section, incl.section
+  end
+
+  def test_add_to_no_document_self
+    incl = RDoc::Include.new 'Name', 'comment'
+    arr = []
+    @context.document_self = false
+    @context.add_to arr, incl
+
+    refute_includes arr, incl
+  end
+
+  def test_add_to_done_documenting
+    incl = RDoc::Include.new 'Name', 'comment'
+    arr = []
+    @context.done_documenting = true
+    @context.add_to arr, incl
+
+    refute_includes arr, incl
+  end
+
+  def test_classes
+    assert_equal %w[C2::C3], @c2.classes.map { |k| k.full_name }
+    assert_equal %w[C3::H1 C3::H2], @c3.classes.map { |k| k.full_name }
+  end
+
+  def test_defined_in_eh
+    assert @c1.defined_in?(@c1.top_level)
+
+    refute @c1.defined_in?(RDoc::TopLevel.new('name.rb'))
+  end
+
+  def test_equals2
+    assert_equal @c3,    @c3
+    refute_equal @c2,    @c3
+    refute_equal @c2_c3, @c3
+  end
+
+  def test_find_attribute_named
+    assert_equal nil,  @c1.find_attribute_named('none')
+    assert_equal 'R',  @c1.find_attribute_named('attr').rw
+    assert_equal 'R',  @c1.find_attribute_named('attr_reader').rw
+    assert_equal 'W',  @c1.find_attribute_named('attr_writer').rw
+    assert_equal 'RW', @c1.find_attribute_named('attr_accessor').rw
+  end
+
+  def test_find_constant_named
+    assert_equal nil,      @c1.find_constant_named('NONE')
+    assert_equal ':const', @c1.find_constant_named('CONST').value
+  end
+
+  def test_find_enclosing_module_named
+    assert_equal nil, @c2_c3.find_enclosing_module_named('NONE')
+    assert_equal @c1, @c2_c3.find_enclosing_module_named('C1')
+    assert_equal @c2, @c2_c3.find_enclosing_module_named('C2')
+  end
+
+  def test_find_file_named
+    assert_equal nil,        @c1.find_file_named('nonexistent.rb')
+    assert_equal @xref_data, @c1.find_file_named(@file_name)
+  end
+
+  def test_find_instance_method_named
+    assert_equal nil, @c1.find_instance_method_named('none')
+
+    m = @c1.find_instance_method_named('m')
+    assert_instance_of RDoc::AnyMethod, m
+    assert_equal false, m.singleton
+  end
+
+  def test_find_local_symbol
+    assert_equal true,       @c1.find_local_symbol('m').singleton
+    assert_equal ':const',   @c1.find_local_symbol('CONST').value
+    assert_equal 'R',        @c1.find_local_symbol('attr').rw
+    assert_equal @xref_data, @c1.find_local_symbol(@file_name)
+    assert_equal @c2_c3,     @c2.find_local_symbol('C3')
+  end
+
+  def test_find_method_named
+    assert_equal true, @c1.find_method_named('m').singleton
+  end
+
+  def test_find_module_named
+    assert_equal @c2_c3, @c2.find_module_named('C3')
+    assert_equal @c2,    @c2.find_module_named('C2')
+    assert_equal @c1,    @c2.find_module_named('C1')
+
+    assert_equal 'C2::C3', @c2.find_module_named('C3').full_name
+  end
+
+  def test_find_symbol
+    c3 = @xref_data.find_module_named('C3')
+    assert_equal c3,     @xref_data.find_symbol('C3')
+    assert_equal c3,     @c2.find_symbol('::C3')
+    assert_equal @c2_c3, @c2.find_symbol('C3')
+  end
+
+  def test_spaceship
+    assert_equal(-1, @c2.<=>(@c3))
+    assert_equal 0,  @c2.<=>(@c2)
+    assert_equal 1,  @c3.<=>(@c2)
+
+    assert_equal 1,  @c2_c3.<=>(@c2)
+    assert_equal(-1, @c2_c3.<=>(@c3))
+  end
+
+end
+