voloko-sdoc 0.1.2 → 0.1.3

data/rdoc/lib/rdoc/any_method.rb

@@ -0,0 +1,190 @@
+require 'rdoc/code_object'
+require 'rdoc/tokenstream'
+
+##
+# AnyMethod is the base class for objects representing methods
+
+class RDoc::AnyMethod < RDoc::CodeObject
+
+  ##
+  # Method name
+
+  attr_writer :name
+
+  ##
+  # public, protected, private
+
+  attr_accessor :visibility
+
+  ##
+  # Parameters yielded by the called block
+
+  attr_accessor :block_params
+
+  ##
+  # Don't rename \#initialize to \::new
+
+  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
+
+  ##
+  # Fragment reference for this method
+
+  attr_reader :aref
+
+  ##
+  # The method we're aliasing
+
+  attr_accessor :is_alias_for
+
+  ##
+  # Parameters for this method
+
+  attr_overridable :params, :param, :parameters, :parameter
+
+  ##
+  # Different ways to call this method
+
+  attr_accessor :call_seq
+
+  include RDoc::TokenStream
+
+  ##
+  # Resets method fragment reference counter
+
+  def self.reset
+    @@aref = 'M000000'
+  end
+
+  reset
+
+  def initialize(text, name)
+    super()
+    @text = text
+    @name = name
+    @token_stream  = nil
+    @visibility    = :public
+    @dont_rename_initialize = false
+    @block_params  = nil
+    @aliases       = []
+    @is_alias_for  = nil
+    @call_seq = nil
+
+    @aref  = @@aref
+    @@aref = @@aref.succ
+  end
+
+  ##
+  # Order by #singleton then #name
+
+  def <=>(other)
+    [@singleton ? 0 : 1, @name] <=> [other.singleton ? 0 : 1, other.name]
+  end
+
+  ##
+  # Adds +method+ as an alias for this method
+
+  def add_alias(method)
+    @aliases << method
+  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 (%s)%s>" % [
+        self.class, object_id,
+        parent_name,
+        singleton ? '::' : '#',
+        name,
+        visibility,
+        alias_for,
+      ]
+  end
+
+  ##
+  # Full method name including namespace
+
+  def full_name
+    "#{@parent.full_name}#{pretty_name}"
+  end
+
+  ##
+  # Method name
+
+  def name
+    return @name if @name
+
+    @name = @call_seq[/^.*?\.(\w+)/, 1] || @call_seq
+  end
+
+  ##
+  # Pretty parameter list for this method
+
+  def param_seq
+    params = params.gsub(/\s*\#.*/, '')
+    params = params.tr("\n", " ").squeeze(" ")
+    params = "(#{params})" unless p[0] == ?(
+
+    if block = block_params then # yes, =
+      # If this method has explicit block parameters, remove any explicit
+      # &block
+      params.sub!(/,?\s*&\w+/)
+
+      block.gsub!(/\s*\#.*/, '')
+      block = block.tr("\n", " ").squeeze(" ")
+      if block[0] == ?(
+        block.sub!(/^\(/, '').sub!(/\)/, '')
+      end
+      params << " { |#{block}| ... }"
+    end
+
+    params
+  end
+
+  ##
+  # Path to this method
+
+  def path
+    "#{@parent.path}##{@aref}"
+  end
+
+  ##
+  # Method name with class/instance indicator
+
+  def pretty_name
+    "#{singleton ? '::' : '#'}#{@name}"
+  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/rdoc/lib/rdoc/attr.rb

@@ -0,0 +1,79 @@
+require 'rdoc/code_object'
+
+##
+# An attribute created by \#attr, \#attr_reader, \#attr_writer or
+# \#attr_accessor
+
+class RDoc::Attr < RDoc::CodeObject
+
+  ##
+  # Name of the attribute
+
+  attr_accessor :name
+
+  ##
+  # Is the attribute readable, writable or both?
+
+  attr_accessor :rw
+
+  ##
+  # Source file token stream
+
+  attr_accessor :text
+
+  ##
+  # public, protected, private
+
+  attr_accessor :visibility
+
+  def initialize(text, name, rw, comment)
+    super()
+    @text = text
+    @name = name
+    @rw = rw
+    @visibility = :public
+    self.comment = comment
+  end
+
+  ##
+  # Attributes are ordered by name
+
+  def <=>(other)
+    self.name <=> other.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,
+      ]
+  end
+
+  ##
+  # URL path for this attribute
+
+  def path
+    "#{@parent.path}##{@name}"
+  end
+
+  def to_s # :nodoc:
+    "attr: #{self.name} #{self.rw}\n#{self.comment}"
+  end
+
+end
+

data/rdoc/lib/rdoc/cache.rb

@@ -0,0 +1,41 @@
+require 'thread'
+require 'singleton'
+
+##
+# A generic, thread-safe in-memory cache. It's used for caching
+# RDoc::TemplatePage objects when generating RDoc output.
+
+class RDoc::Cache
+
+  include Singleton
+
+  ##
+  # Creates a new, empty cache
+
+  def initialize
+    @contents = {}
+    @lock = Mutex.new
+  end
+
+  ##
+  # Checks whether there's a value in the cache with key +key+. If so, then
+  # that value will be returned. Otherwise, the given block will be run, and
+  # its return value will be put into the cache, and returned.
+
+  def cache(key)
+    @lock.synchronize do
+      @contents[key] ||= yield
+    end
+  end
+
+  ##
+  # Clears the contents of the cache
+
+  def clear
+    @lock.synchronize do
+      @contents.clear
+    end
+  end
+
+end
+

data/rdoc/lib/rdoc/class_module.rb

@@ -0,0 +1,87 @@
+require 'rdoc/context'
+
+##
+# ClassModule is the base class for objects representing either a class or a
+# module.
+
+class RDoc::ClassModule < RDoc::Context
+
+  attr_accessor :diagram
+
+  ##
+  # Creates a new ClassModule with +name+ with optional +superclass+
+
+  def initialize(name, superclass = 'Object')
+    @diagram    = nil
+    @full_name  = nil
+    @name       = name
+    @superclass = superclass
+    super()
+  end
+
+  ##
+  # Finds a class or module with +name+ in this namespace or its descendents
+
+  def find_class_named(name)
+    return self if full_name == name
+    @classes.each_value {|c| return c if c.find_class_named(name) }
+    nil
+  end
+
+  ##
+  # Return the fully qualified name of this class or module
+
+  def full_name
+    @full_name ||= if RDoc::ClassModule === @parent then
+                     "#{@parent.full_name}::#{@name}"
+                   else
+                     @name
+                   end
+  end
+
+  ##
+  # 'module' or 'class'
+
+  def type
+    module? ? 'module' : 'class'
+  end
+
+  ##
+  # Does this object represent a module?
+
+  def module?
+    false
+  end
+
+  ##
+  # Path to this class or module
+
+  def path
+    http_url RDoc::RDoc.current.generator.class_dir
+  end
+
+  ##
+  # Get the superclass of this class.  Attempts to retrieve the superclass
+  # object, returns the name if it is not known.
+
+  def superclass
+    raise NoMethodError, "#{full_name} is a module" if module?
+
+    RDoc::TopLevel.find_class_named(@superclass) || @superclass
+  end
+
+  ##
+  # Set the superclass of this class to +superclass+
+
+  def superclass=(superclass)
+    raise NoMethodError, "#{full_name} is a module" if module?
+
+    @superclass = superclass if @superclass.nil? or @superclass == 'Object'
+  end
+
+  def to_s # :nodoc:
+    "#{self.class}: #{full_name} #{@comment} #{super}"
+  end
+
+end
+

data/rdoc/lib/rdoc/code_object.rb

@@ -0,0 +1,152 @@
+require 'rdoc'
+
+##
+# We contain the common stuff for contexts (which are containers) and other
+# elements (methods, attributes and so on)
+
+class RDoc::CodeObject
+
+  ##
+  # Our comment
+
+  attr_reader :comment
+
+  ##
+  # Do we document our children?
+
+  attr_reader :document_children
+
+  ##
+  # Do we document ourselves?
+
+  attr_reader :document_self
+
+  ##
+  # Are we done documenting (ie, did we come across a :enddoc:)?
+
+  attr_accessor :done_documenting
+
+  ##
+  # Force documentation of this CodeObject
+
+  attr_accessor :force_documentation
+
+  ##
+  # Our parent CodeObject
+
+  attr_accessor :parent
+
+  ##
+  # Which section are we in
+
+  attr_accessor :section
+
+  ##
+  # We are the model of the code, but we know that at some point we will be
+  # worked on by viewers. By implementing the Viewable protocol, viewers can
+  # associated themselves with these objects.
+
+  attr_accessor :viewer
+
+  ##
+  # There's a wee trick we pull. Comment blocks can have directives that
+  # override the stuff we extract during the parse. So, we have a special
+  # class method, attr_overridable, that lets code objects list those
+  # directives. When a comment is assigned, we then extract out any matching
+  # directives and update our object
+
+  def self.attr_overridable(name, *aliases)
+    @overridables ||= {}
+
+    attr_accessor name
+
+    aliases.unshift name
+
+    aliases.each do |directive_name|
+      @overridables[directive_name.to_s] = name
+    end
+  end
+
+  ##
+  # Creates a new CodeObject that will document itself and its children
+
+  def initialize
+    @comment = nil
+    @document_children = true
+    @document_self = true
+    @done_documenting = false
+    @force_documentation = false
+    @parent = nil
+  end
+
+  ##
+  # Replaces our comment with +comment+, unless it is empty.
+
+  def comment=(comment)
+    @comment = comment unless comment.empty?
+  end
+
+  ##
+  # Enables or disables documentation of this CodeObject's children.  Calls
+  # remove_classes_and_modules when disabling.
+
+  def document_children=(document_children)
+    @document_children = document_children
+    remove_classes_and_modules unless document_children
+  end
+
+  ##
+  # Enables or disables documentation of this CodeObject.  Calls
+  # remove_methods_etc when disabling.
+
+  def document_self=(document_self)
+    @document_self = document_self
+    remove_methods_etc unless document_self
+  end
+
+  ##
+  # File name of our parent
+
+  def parent_file_name
+    @parent ? @parent.base_name : '(unknown)'
+  end
+
+  ##
+  # Name of our parent
+
+  def parent_name
+    @parent ? @parent.full_name : '(unknown)'
+  end
+
+  ##
+  # Callback called upon disabling documentation of children.  See
+  # #document_children=
+
+  def remove_classes_and_modules
+  end
+
+  ##
+  # Callback called upon disabling documentation of ourself.  See
+  # #document_self=
+
+  def remove_methods_etc
+  end
+
+  ##
+  # Enable capture of documentation
+
+  def start_doc
+    @document_self = true
+    @document_children = true
+  end
+
+  ##
+  # Disable capture of documentation
+
+  def stop_doc
+    @document_self = false
+    @document_children = false
+  end
+
+end
+

data/rdoc/lib/rdoc/code_objects.rb

@@ -0,0 +1,23 @@
+# We represent the various high-level code constructs that appear in Ruby
+# programs: classes, modules, methods, and so on.
+
+require 'rdoc/code_object'
+require 'rdoc/context'
+require 'rdoc/top_level'
+
+require 'rdoc/class_module'
+require 'rdoc/normal_class'
+require 'rdoc/normal_module'
+require 'rdoc/anon_class'
+require 'rdoc/single_class'
+
+require 'rdoc/any_method'
+require 'rdoc/alias'
+require 'rdoc/ghost_method'
+require 'rdoc/meta_method'
+
+require 'rdoc/attr'
+require 'rdoc/constant'
+require 'rdoc/require'
+require 'rdoc/include'
+

data/rdoc/lib/rdoc/constant.rb

@@ -0,0 +1,36 @@
+require 'rdoc/code_object'
+
+##
+# A constant
+
+class RDoc::Constant < RDoc::CodeObject
+
+  ##
+  # The constant's name
+
+  attr_accessor :name
+
+  ##
+  # The constant's value
+
+  attr_accessor :value
+
+  ##
+  # Creates a new constant with +name+, +value+ and +comment+
+
+  def initialize(name, value, comment)
+    super()
+    @name = name
+    @value = value
+    self.comment = comment
+  end
+
+  ##
+  # Path to this constant
+
+  def path
+    "#{@parent.path}##{@name}"
+  end
+
+end
+