rdoc 2.5.11 → 3.0

data/lib/rdoc/alias.rb

@@ -3,49 +3,75 @@ require 'rdoc/code_object'
 ##
 # Represent an alias, which is an old_name/new_name pair associated with a
 # particular context
-#
-# TODO: RDoc::Alias needs to know if it's a singleton alias or not
+#--
+# TODO implement Alias as a proxy to a method/attribute, inheriting from
+#      MethodAttr
 
 class RDoc::Alias < RDoc::CodeObject
 
   ##
-  # Allow comments to be overridden
+  # Aliased method's name
 
-  attr_writer :comment
+  attr_reader :new_name
 
-  ##
-  # Aliased name
-
-  attr_accessor :new_name
+  alias name new_name
 
   ##
-  # Aliasee's name
+  # Aliasee method's name
 
-  attr_accessor :old_name
+  attr_reader :old_name
 
   ##
-  # Is this a singeton alias?
+  # Is this an alias declared in a singleton context?
 
   attr_accessor :singleton
 
   ##
   # Source file token stream
 
-  attr_accessor :text
+  attr_reader :text
 
   ##
   # Creates a new Alias with a token stream of +text+ that aliases +old_name+
-  # to +new_name+ and has +comment+
+  # to +new_name+, has +comment+ and is a +singleton+ context.
 
-  def initialize(text, old_name, new_name, comment)
+  def initialize(text, old_name, new_name, comment, singleton = false)
     super()
 
     @text = text
+    @singleton = singleton
     @old_name = old_name
     @new_name = new_name
     self.comment = comment
+  end
+
+  ##
+  # Order by #singleton then #new_name
+
+  def <=>(other)
+    [@singleton ? 0 : 1, new_name] <=> [other.singleton ? 0 : 1, other.new_name]
+  end
+
+  ##
+  # HTML fragment reference for this alias
+
+  def aref
+    type = singleton ? 'c' : 'i'
+    "#alias-#{type}-#{html_name}"
+  end
+
+  ##
+  # Full old name including namespace
+
+  def full_old_name
+    @full_name || "#{parent.name}#{pretty_old_name}"
+  end
 
-    @singleton = false
+  ##
+  # HTML id-friendly version of +#new_name+.
+
+  def html_name
+    CGI.escape(@new_name.gsub('-', '-2D')).gsub('%','-').sub(/^-/, '')
   end
 
   def inspect # :nodoc:
@@ -56,8 +82,31 @@ class RDoc::Alias < RDoc::CodeObject
     ]
   end
 
+  ##
+  # '::' for the alias of a singleton method/attribute, '#' for instance-level.
+
+  def name_prefix
+    singleton ? '::' : '#'
+  end
+
+  ##
+  # Old name with prefix '::' or '#'.
+
+  def pretty_old_name
+    "#{singleton ? '::' : '#'}#{@old_name}"
+  end
+
+  ##
+  # New name with prefix '::' or '#'.
+
+  def pretty_new_name
+    "#{singleton ? '::' : '#'}#{@new_name}"
+  end
+
+  alias pretty_name pretty_new_name
+
   def to_s # :nodoc:
-    "alias: #{self.old_name} -> #{self.new_name}\n#{self.comment}"
+    "alias: #{self.new_name} -> #{self.pretty_old_name} in: #{parent}"
   end
 
 end

data/lib/rdoc/any_method.rb

@@ -1,29 +1,12 @@
-require 'rdoc/code_object'
-require 'rdoc/tokenstream'
+require 'rdoc/method_attr'
+require 'rdoc/token_stream'
 
 ##
 # AnyMethod is the base class for objects representing methods
 
-class RDoc::AnyMethod < RDoc::CodeObject
+class RDoc::AnyMethod < RDoc::MethodAttr
 
-  MARSHAL_VERSION = 1 # :nodoc:
-
-  include Comparable
-
-  ##
-  # Method name
-
-  attr_writer :name
-
-  ##
-  # public, protected, private
-
-  attr_accessor :visibility
-
-  ##
-  # Parameters yielded by the called block
-
-  attr_accessor :block_params
+  MARSHAL_VERSION = 0 # :nodoc:
 
   ##
   # Don't rename \#initialize to \::new
@@ -31,76 +14,49 @@ class RDoc::AnyMethod < RDoc::CodeObject
   attr_accessor :dont_rename_initialize
 
   ##
-  # Is this a singleton method?
-
-  attr_accessor :singleton
-
-  ##
-  # Source file token stream
-
-  attr_reader :text
-
-  ##
-  # Array of other names for this method
-
-  attr_reader :aliases
-
-  ##
-  # The method we're aliasing
+  # Different ways to call this method
 
-  attr_accessor :is_alias_for
+  attr_accessor :call_seq
 
   ##
   # Parameters for this method
 
   attr_accessor :params
 
-  ##
-  # Different ways to call this method
-
-  attr_accessor :call_seq
-
   include RDoc::TokenStream
 
-  def initialize(text, name)
-    super()
+  ##
+  # Creates a new AnyMethod with a token stream +text+ and +name+
 
-    @text = text
-    @name = name
+  def initialize text, name
+    super
 
-    @aliases                = []
-    @block_params           = nil
-    @call_seq               = nil
     @dont_rename_initialize = false
-    @is_alias_for           = nil
-    @params                 = nil
-    @parent_name            = nil
-    @singleton              = nil
     @token_stream           = nil
-    @visibility             = :public
   end
 
   ##
-  # Order by #singleton then #name
+  # Adds +an_alias+ as an alias for this method in +context+.
 
-  def <=>(other)
-    [@singleton ? 0 : 1, @name] <=> [other.singleton ? 0 : 1, other.name]
-  end
-
-  ##
-  # Adds +method+ as an alias for this method
+  def add_alias(an_alias, context)
+    method = self.class.new an_alias.text, an_alias.new_name
 
-  def add_alias(method)
+    method.record_location an_alias.file
+    method.singleton = self.singleton
+    method.params = self.params
+    method.visibility = self.visibility
+    method.comment = an_alias.comment
+    method.is_alias_for = self
     @aliases << method
+    context.add_method method
+    method
   end
 
   ##
-  # HTML fragment reference for this method
+  # Prefix for +aref+ is 'method'.
 
-  def aref
-    type = singleton ? 'c' : 'i'
-
-    "method-#{type}-#{CGI.escape name}"
+  def aref_prefix
+    'method'
   end
 
   ##
@@ -116,30 +72,6 @@ class RDoc::AnyMethod < RDoc::CodeObject
     end
   end
 
-  ##
-  # HTML id-friendly method name
-
-  def html_name
-    @name.gsub(/[^a-z]+/, '-')
-  end
-
-  def inspect # :nodoc:
-    alias_for = @is_alias_for ? " (alias for #{@is_alias_for.name})" : nil
-    "#<%s:0x%x %s (%s)%s>" % [
-      self.class, object_id,
-      full_name,
-      visibility,
-      alias_for,
-    ]
-  end
-
-  ##
-  # Full method name including namespace
-
-  def full_name
-    @full_name ||= "#{@parent ? @parent.full_name : '(unknown)'}#{pretty_name}"
-  end
-
   ##
   # Dumps this AnyMethod for use by ri.  See also #marshal_load
 
@@ -192,12 +124,14 @@ class RDoc::AnyMethod < RDoc::CodeObject
                    end
 
     array[8].each do |new_name, comment|
-      add_alias RDoc::Alias.new(nil, @name, new_name, comment)
+      add_alias RDoc::Alias.new(nil, @name, new_name, comment, @singleton)
     end
   end
 
   ##
   # Method name
+  #
+  # If the method has no assigned name, it extracts it from #call_seq.
 
   def name
     return @name if @name
@@ -229,62 +163,5 @@ class RDoc::AnyMethod < RDoc::CodeObject
     params
   end
 
-  ##
-  # Name of our parent with special handling for un-marshaled methods
-
-  def parent_name
-    @parent_name || super
-  end
-
-  ##
-  # Path to this method
-
-  def path
-    "#{@parent.path}##{aref}"
-  end
-
-  ##
-  # Method name with class/instance indicator
-
-  def pretty_name
-    "#{singleton ? '::' : '#'}#{@name}"
-  end
-
-  def pretty_print q # :nodoc:
-    alias_for = @is_alias_for ? "alias for #{@is_alias_for.name}" : nil
-
-    q.group 2, "[#{self.class.name} #{full_name} #{visibility}", "]" do
-      if alias_for then
-        q.breakable
-        q.text alias_for
-      end
-
-      if text then
-        q.breakable
-        q.text "text:"
-        q.breakable
-        q.pp @text
-      end
-
-      unless comment.empty? then
-        q.breakable
-        q.text "comment:"
-        q.breakable
-        q.pp @comment
-      end
-    end
-  end
-
-  def to_s # :nodoc:
-    "#{self.class.name}: #{full_name} (#{@text})\n#{@comment}"
-  end
-
-  ##
-  # Type of method (class or instance)
-
-  def type
-    singleton ? 'class' : 'instance'
-  end
-
 end
 

data/lib/rdoc/attr.rb

@@ -1,113 +1,71 @@
-require 'rdoc/code_object'
+require 'rdoc/method_attr'
 
 ##
 # An attribute created by \#attr, \#attr_reader, \#attr_writer or
 # \#attr_accessor
 
-class RDoc::Attr < RDoc::CodeObject
+class RDoc::Attr < RDoc::MethodAttr
 
-  MARSHAL_VERSION = 0 # :nodoc:
+  MARSHAL_VERSION = 1 # :nodoc:
 
   ##
-  # Name of the attribute
-
-  attr_accessor :name
-
-  ##
-  # Is the attribute readable, writable or both?
+  # Is the attribute readable ('R'), writable ('W') or both ('RW')?
 
   attr_accessor :rw
 
   ##
-  # Source file token stream
+  # Creates a new Attr with body +text+, +name+, read/write status +rw+ and
+  # +comment+.  +singleton+ marks this as a class attribute.
 
-  attr_accessor :text
+  def initialize(text, name, rw, comment, singleton = false)
+    super text, name
 
-  ##
-  # public, protected, private
-
-  attr_accessor :visibility
-
-  def initialize(text, name, rw, comment)
-    super()
-    @text = text
-    @name = name
     @rw = rw
-    @visibility = :public
+    @singleton = singleton
     self.comment = comment
   end
 
   ##
-  # Attributes are ordered by name
-
-  def <=>(other)
-    self.name <=> other.name
-  end
-
-  ##
-  # Attributes are equal when their names and rw is identical
+  # Attributes are equal when their names, singleton and rw are identical
 
   def == other
     self.class == other.class and
       self.name == other.name and
-      self.rw == other.rw
+      self.rw == other.rw and
+      self.singleton == other.singleton
   end
 
   ##
-  # HTML fragment reference for this attr
-
-  def aref
-    type = singleton ? 'c' : 'i'
+  # Add +an_alias+ as an attribute in +context+.
 
-    "attribute-#{type}-#{CGI.escape name}"
-  end
-
-  ##
-  # Returns nil, for duck typing with RDoc::AnyMethod
+  def add_alias(an_alias, context)
+    new_attr = self.class.new(self.text, an_alias.new_name, self.rw,
+                              self.comment, self.singleton)
 
-  def arglists
+    new_attr.record_location an_alias.file
+    new_attr.visibility = self.visibility
+    new_attr.is_alias_for = self
+    @aliases << new_attr
+    context.add_attribute new_attr
+    new_attr
   end
 
   ##
-  # Returns nil, for duck typing with RDoc::AnyMethod
+  # The #aref prefix for attributes
 
-  def block_params
+  def aref_prefix
+    'attribute'
   end
 
   ##
-  # Returns nil, for duck typing with RDoc::AnyMethod
+  # Returns attr_reader, attr_writer or attr_accessor as appropriate.
 
-  def call_seq
-  end
-
-  ##
-  # Partially bogus as Attr has no parent.  For duck typing with
-  # RDoc::AnyMethod.
-
-  def full_name
-    @full_name ||= "#{@parent ? @parent.full_name : '(unknown)'}##{name}"
-  end
-
-  ##
-  # An HTML id-friendly representation of #name
-
-  def html_name
-    @name.gsub(/[^a-z]+/, '-')
-  end
-
-  def inspect # :nodoc:
-    attr = case rw
-           when 'RW' then :attr_accessor
-           when 'R'  then :attr_reader
-           when 'W'  then :attr_writer
-           else
-               " (#{rw})"
-           end
-
-      "#<%s:0x%x %s.%s :%s>" % [
-        self.class, object_id,
-        parent_name, attr, @name,
-      ]
+  def definition
+    case @rw
+    when 'RW' then 'attr_accessor'
+    when 'R'  then 'attr_reader'
+    when 'W'  then 'attr_writer'
+    end
   end
 
   ##
@@ -120,11 +78,12 @@ class RDoc::Attr < RDoc::CodeObject
       @rw,
       @visibility,
       parse(@comment),
+      singleton,
     ]
   end
 
   ##
-  # Loads this AnyMethod from +array+.  For a loaded AnyMethod the following
+  # Loads this Attr from +array+.  For a loaded Attr the following
   # methods will return cached values:
   #
   # * #full_name
@@ -136,51 +95,13 @@ class RDoc::Attr < RDoc::CodeObject
     @rw         = array[3]
     @visibility = array[4]
     @comment    = array[5]
+    @singleton  = array[6] || false # MARSHAL_VERSION == 0
 
     @parent_name = @full_name
   end
 
-  ##
-  # Name of our parent with special handling for un-marshaled methods
-
-  def parent_name
-    @parent_name || super
-  end
-
-  ##
-  # For duck typing with RDoc::AnyMethod, returns nil
-
-  def params
-    nil
-  end
-
-  ##
-  # URL path for this attribute
-
-  def path
-    "#{@parent.path}##{@name}"
-  end
-
-  ##
-  # For duck typing with RDoc::AnyMethod
-
-  def singleton
-    false
-  end
-
   def to_s # :nodoc:
-    "#{type} #{name}\n#{comment}"
-  end
-
-  ##
-  # Returns attr_reader, attr_writer or attr_accessor as appropriate
-
-  def type
-    case @rw
-    when 'RW' then 'attr_accessor'
-    when 'R'  then 'attr_reader'
-    when 'W'  then 'attr_writer'
-    end
+    "#{definition} #{name} in: #{parent}"
   end
 
 end