2008-07-17 20:46:16 -04:00
|
|
|
##
|
2003-12-01 02:12:49 -05:00
|
|
|
# This file contains stuff stolen outright from:
|
|
|
|
#
|
2008-01-13 22:34:05 -05:00
|
|
|
# rtags.rb -
|
2008-06-04 05:37:38 -04:00
|
|
|
# ruby-lex.rb - ruby lexcal analyzer
|
2008-01-13 22:34:05 -05:00
|
|
|
# ruby-token.rb - ruby tokens
|
2008-07-17 20:46:16 -04:00
|
|
|
# by Keiju ISHITSUKA (Nippon Rational Inc.)
|
2003-12-01 02:12:49 -05:00
|
|
|
#
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
require 'rdoc/ruby_token'
|
|
|
|
require 'rdoc/ruby_lex'
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
require 'rdoc/code_objects'
|
2010-12-19 22:22:49 -05:00
|
|
|
require 'rdoc/token_stream'
|
|
|
|
require 'rdoc/markup/pre_process'
|
2008-07-17 20:46:16 -04:00
|
|
|
require 'rdoc/parser'
|
2010-04-01 03:45:16 -04:00
|
|
|
require 'rdoc/parser/ruby_tools'
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-04-04 17:16:19 -04:00
|
|
|
$TOKEN_DEBUG ||= nil
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-01-07 01:56:46 -05:00
|
|
|
##
|
2008-07-17 20:46:16 -04:00
|
|
|
# Extracts code elements from a source file returning a TopLevel object
|
2008-01-07 01:56:46 -05:00
|
|
|
# containing the constituent file elements.
|
2003-12-01 02:12:49 -05:00
|
|
|
#
|
|
|
|
# This file is based on rtags
|
2008-07-17 20:46:16 -04:00
|
|
|
#
|
|
|
|
# RubyParser understands how to document:
|
|
|
|
# * classes
|
|
|
|
# * modules
|
|
|
|
# * methods
|
|
|
|
# * constants
|
|
|
|
# * aliases
|
|
|
|
# * private, public, protected
|
|
|
|
# * private_class_function, public_class_function
|
|
|
|
# * module_function
|
|
|
|
# * attr, attr_reader, attr_writer, attr_accessor
|
|
|
|
# * extra accessors given on the command line
|
|
|
|
# * metaprogrammed methods
|
|
|
|
# * require
|
|
|
|
# * include
|
|
|
|
#
|
|
|
|
# == Method Arguments
|
|
|
|
#
|
|
|
|
#--
|
|
|
|
# NOTE: I don't think this works, needs tests, remove the paragraph following
|
|
|
|
# this block when known to work
|
|
|
|
#
|
|
|
|
# The parser extracts the arguments from the method definition. You can
|
|
|
|
# override this with a custom argument definition using the :args: directive:
|
|
|
|
#
|
|
|
|
# ##
|
|
|
|
# # This method tries over and over until it is tired
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2008-07-17 20:46:16 -04:00
|
|
|
# def go_go_go(thing_to_try, tries = 10) # :args: thing_to_try
|
|
|
|
# puts thing_to_try
|
|
|
|
# go_go_go thing_to_try, tries - 1
|
|
|
|
# end
|
|
|
|
#
|
|
|
|
# If you have a more-complex set of overrides you can use the :call-seq:
|
|
|
|
# directive:
|
|
|
|
#++
|
|
|
|
#
|
|
|
|
# The parser extracts the arguments from the method definition. You can
|
|
|
|
# override this with a custom argument definition using the :call-seq:
|
|
|
|
# directive:
|
|
|
|
#
|
|
|
|
# ##
|
|
|
|
# # This method can be called with a range or an offset and length
|
|
|
|
# #
|
|
|
|
# # :call-seq:
|
|
|
|
# # my_method(Range)
|
|
|
|
# # my_method(offset, length)
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2008-07-17 20:46:16 -04:00
|
|
|
# def my_method(*args)
|
|
|
|
# end
|
|
|
|
#
|
|
|
|
# The parser extracts +yield+ expressions from method bodies to gather the
|
|
|
|
# yielded argument names. If your method manually calls a block instead of
|
|
|
|
# yielding or you want to override the discovered argument names use
|
|
|
|
# the :yields: directive:
|
|
|
|
#
|
|
|
|
# ##
|
|
|
|
# # My method is awesome
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2008-07-17 20:46:16 -04:00
|
|
|
# def my_method(&block) # :yields: happy, times
|
|
|
|
# block.call 1, 2
|
|
|
|
# end
|
|
|
|
#
|
|
|
|
# == Metaprogrammed Methods
|
|
|
|
#
|
|
|
|
# To pick up a metaprogrammed method, the parser looks for a comment starting
|
|
|
|
# with '##' before an identifier:
|
|
|
|
#
|
|
|
|
# ##
|
|
|
|
# # This is a meta-programmed method!
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2008-07-17 20:46:16 -04:00
|
|
|
# add_my_method :meta_method, :arg1, :arg2
|
|
|
|
#
|
|
|
|
# The parser looks at the token after the identifier to determine the name, in
|
|
|
|
# this example, :meta_method. If a name cannot be found, a warning is printed
|
|
|
|
# and 'unknown is used.
|
|
|
|
#
|
|
|
|
# You can force the name of a method using the :method: directive:
|
|
|
|
#
|
|
|
|
# ##
|
|
|
|
# # :method: woo_hoo!
|
|
|
|
#
|
|
|
|
# By default, meta-methods are instance methods. To indicate that a method is
|
|
|
|
# a singleton method instead use the :singleton-method: directive:
|
|
|
|
#
|
|
|
|
# ##
|
|
|
|
# # :singleton-method:
|
|
|
|
#
|
|
|
|
# You can also use the :singleton-method: directive with a name:
|
|
|
|
#
|
|
|
|
# ##
|
|
|
|
# # :singleton-method: woo_hoo!
|
|
|
|
#
|
2010-04-01 03:45:16 -04:00
|
|
|
# Additionally you can mark a method as an attribute by
|
|
|
|
# using :attr:, :attr_reader:, :attr_writer: or :attr_accessor:. Just like
|
|
|
|
# for :method:, the name is optional.
|
|
|
|
#
|
|
|
|
# ##
|
|
|
|
# # :attr_reader: my_attr_name
|
|
|
|
#
|
|
|
|
# == Hidden methods and attributes
|
2008-07-17 20:46:16 -04:00
|
|
|
#
|
|
|
|
# You can provide documentation for methods that don't appear using
|
2010-04-01 03:45:16 -04:00
|
|
|
# the :method:, :singleton-method: and :attr: directives:
|
2008-07-17 20:46:16 -04:00
|
|
|
#
|
|
|
|
# ##
|
2010-04-01 03:45:16 -04:00
|
|
|
# # :attr_writer: ghost_writer
|
|
|
|
# # There is an attribute here, but you can't see it!
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2010-04-01 03:45:16 -04:00
|
|
|
# ##
|
2008-07-17 20:46:16 -04:00
|
|
|
# # :method: ghost_method
|
|
|
|
# # There is a method here, but you can't see it!
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2008-07-17 20:46:16 -04:00
|
|
|
# ##
|
|
|
|
# # this is a comment for a regular method
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2008-07-17 20:46:16 -04:00
|
|
|
# def regular_method() end
|
|
|
|
#
|
|
|
|
# Note that by default, the :method: directive will be ignored if there is a
|
|
|
|
# standard rdocable item following it.
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
class RDoc::Parser::Ruby < RDoc::Parser
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-10 02:36:13 -04:00
|
|
|
parse_files_matching(/\.rbw?$/)
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
include RDoc::RubyToken
|
|
|
|
include RDoc::TokenStream
|
2010-04-01 03:45:16 -04:00
|
|
|
include RDoc::Parser::RubyTools
|
|
|
|
|
|
|
|
##
|
|
|
|
# RDoc::NormalClass type
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
NORMAL = "::"
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
##
|
|
|
|
# RDoc::SingleClass type
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
SINGLE = "<<"
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Creates a new Ruby parser.
|
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
def initialize(top_level, file_name, content, options, stats)
|
2008-07-17 20:46:16 -04:00
|
|
|
super
|
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
@size = 0
|
|
|
|
@token_listeners = nil
|
2008-07-17 20:46:16 -04:00
|
|
|
@scanner = RDoc::RubyLex.new content, @options
|
2008-01-13 22:34:05 -05:00
|
|
|
@scanner.exception_on_syntax_error = false
|
2010-04-01 03:45:16 -04:00
|
|
|
@prev_seek = nil
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2011-02-01 19:32:30 -05:00
|
|
|
@encoding = nil
|
|
|
|
@encoding = @options.encoding if Object.const_defined? :Encoding
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
reset
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
##
|
|
|
|
# Look for the first comment in a file that isn't a shebang line.
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
def collect_first_comment
|
|
|
|
skip_tkspace
|
2010-04-01 03:45:16 -04:00
|
|
|
comment = ''
|
2011-02-01 19:32:30 -05:00
|
|
|
comment.force_encoding @encoding if @encoding
|
2008-01-13 22:34:05 -05:00
|
|
|
first_line = true
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
tk = get_tk
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
while TkCOMMENT === tk
|
|
|
|
if first_line and tk.text =~ /\A#!/ then
|
2008-06-21 02:57:28 -04:00
|
|
|
skip_tkspace
|
|
|
|
tk = get_tk
|
2008-07-17 20:46:16 -04:00
|
|
|
elsif first_line and tk.text =~ /\A#\s*-\*-/ then
|
2008-06-21 02:57:28 -04:00
|
|
|
first_line = false
|
2008-01-13 22:34:05 -05:00
|
|
|
skip_tkspace
|
|
|
|
tk = get_tk
|
|
|
|
else
|
2008-06-21 02:57:28 -04:00
|
|
|
first_line = false
|
2010-04-01 03:45:16 -04:00
|
|
|
comment << tk.text << "\n"
|
2008-01-13 22:34:05 -05:00
|
|
|
tk = get_tk
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
if TkNL === tk then
|
|
|
|
skip_tkspace false
|
2003-12-01 02:12:49 -05:00
|
|
|
tk = get_tk
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
unget_tk tk
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
comment
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Aborts with +msg+
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def error(msg)
|
|
|
|
msg = make_message msg
|
2010-12-19 22:22:49 -05:00
|
|
|
|
|
|
|
abort msg
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
##
|
|
|
|
# Look for a 'call-seq' in the comment, and override the normal parameter
|
|
|
|
# stuff
|
2010-12-28 17:08:56 -05:00
|
|
|
#--
|
|
|
|
# TODO handle undent
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def extract_call_seq(comment, meth)
|
2010-12-28 17:08:56 -05:00
|
|
|
if comment.sub!(/:?call-seq:(.*?)(^\s*#?\s*$|\z)/m, '') then
|
2008-07-17 20:46:16 -04:00
|
|
|
seq = $1
|
|
|
|
seq.gsub!(/^\s*\#\s*/, '')
|
|
|
|
meth.call_seq = seq
|
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
meth
|
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Looks for a true or false token. Returns false if TkFALSE or TkNIL are
|
|
|
|
# found.
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def get_bool
|
|
|
|
skip_tkspace
|
|
|
|
tk = get_tk
|
|
|
|
case tk
|
|
|
|
when TkTRUE
|
|
|
|
true
|
|
|
|
when TkFALSE, TkNIL
|
|
|
|
false
|
2008-01-13 22:34:05 -05:00
|
|
|
else
|
2008-07-17 20:46:16 -04:00
|
|
|
unget_tk tk
|
|
|
|
true
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
##
|
2008-01-13 22:34:05 -05:00
|
|
|
# Look for the name of a class of module (optionally with a leading :: or
|
2010-12-19 22:22:49 -05:00
|
|
|
# with :: separated named) and return the ultimate name, the associated
|
|
|
|
# container, and the given name (with the ::).
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
def get_class_or_module(container)
|
|
|
|
skip_tkspace
|
|
|
|
name_t = get_tk
|
2010-12-19 22:22:49 -05:00
|
|
|
given_name = ''
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
# class ::A -> A is in the top level
|
2010-04-01 03:45:16 -04:00
|
|
|
case name_t
|
|
|
|
when TkCOLON2, TkCOLON3 then # bug
|
2008-01-13 22:34:05 -05:00
|
|
|
name_t = get_tk
|
|
|
|
container = @top_level
|
2010-12-19 22:22:49 -05:00
|
|
|
given_name << '::'
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2010-12-19 22:22:49 -05:00
|
|
|
given_name << name_t.name
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
while TkCOLON2 === peek_tk do
|
2008-01-13 22:34:05 -05:00
|
|
|
prev_container = container
|
2010-04-01 03:45:16 -04:00
|
|
|
container = container.find_module_named name_t.name
|
|
|
|
unless container then
|
2008-01-13 22:34:05 -05:00
|
|
|
container = prev_container.add_module RDoc::NormalModule, name_t.name
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
get_tk
|
|
|
|
name_t = get_tk
|
2010-12-19 22:22:49 -05:00
|
|
|
given_name << '::' << name_t.name
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2010-12-19 22:22:49 -05:00
|
|
|
return [container, name_t, given_name]
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
##
|
|
|
|
# Return a superclass, which can be either a constant of an expression
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def get_class_specification
|
|
|
|
tk = get_tk
|
|
|
|
return "self" if TkSELF === tk
|
|
|
|
|
|
|
|
res = ""
|
|
|
|
while TkCOLON2 === tk or TkCOLON3 === tk or TkCONSTANT === tk do
|
2010-04-01 03:45:16 -04:00
|
|
|
res += tk.name
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
unget_tk(tk)
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2004-02-23 16:10:42 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
get_tkread # empty out read buffer
|
2004-02-23 16:10:42 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
tk = get_tk
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
case tk
|
|
|
|
when TkNL, TkCOMMENT, TkSEMICOLON then
|
2008-01-13 22:34:05 -05:00
|
|
|
unget_tk(tk)
|
2008-07-17 20:46:16 -04:00
|
|
|
return res
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
res += parse_call_parameters(tk)
|
|
|
|
res
|
|
|
|
end
|
2004-02-23 16:10:42 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
##
|
|
|
|
# Parse a constant, which might be qualified by one or more class or module
|
|
|
|
# names
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def get_constant
|
|
|
|
res = ""
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
while TkCOLON2 === tk or TkCOLON3 === tk or TkCONSTANT === tk do
|
2010-04-01 03:45:16 -04:00
|
|
|
res += tk.name
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
# if res.empty?
|
|
|
|
# warn("Unexpected token #{tk} in constant")
|
|
|
|
# end
|
|
|
|
unget_tk(tk)
|
|
|
|
res
|
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
##
|
|
|
|
# Get a constant that may be surrounded by parens
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def get_constant_with_optional_parens
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
nest = 0
|
|
|
|
while TkLPAREN === (tk = peek_tk) or TkfLPAREN === tk do
|
|
|
|
get_tk
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace
|
2008-07-17 20:46:16 -04:00
|
|
|
nest += 1
|
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
name = get_constant
|
* array.c: replace rb_protect_inspect() and rb_inspecting_p() by
rb_exec_recursive() in eval.c.
* eval.c (rb_exec_recursive): new function.
* array.c (rb_ary_join): use rb_exec_recursive().
* array.c (rb_ary_inspect, rb_ary_hash): ditto.
* file.c (rb_file_join): ditto.
* hash.c (rb_hash_inspect, rb_hash_to_s, rb_hash_hash): ditto.
* io.c (rb_io_puts): ditto.
* object.c (rb_obj_inspect): ditto
* struct.c (rb_struct_inspect): ditto.
* lib/set.rb (SortedSet::setup): a hack to shut up warning.
[ruby-talk:132866]
* lib/time.rb (Time::strptime): add new function. inspired by
[ruby-talk:132815].
* lib/parsedate.rb (ParseDate::strptime): ditto.
* regparse.c: move st_*_strend() functions from st.c. fixed some
potential memory leaks.
* exception error messages updated. [ruby-core:04497]
* ext/socket/socket.c (Init_socket): add bunch of Socket
constants. Patch from Sam Roberts <sroberts@uniserve.com>.
[ruby-core:04409]
* array.c (rb_ary_s_create): no need for negative argc check.
[ruby-core:04463]
* array.c (rb_ary_unshift_m): ditto.
* lib/xmlrpc/parser.rb (XMLRPC::FaultException): make it subclass
of StandardError class, not Exception class. [ruby-core:04429]
* parse.y (fcall_gen): lvar(arg) will be evaluated as
lvar.call(arg) when lvar is a defined local variable. [new]
* object.c (rb_class_initialize): call inherited method before
calling initializing block.
* eval.c (rb_thread_start_1): initialize newly pushed frame.
* lib/open3.rb (Open3::popen3): $? should not be EXIT_FAILURE.
fixed: [ruby-core:04444]
* eval.c (is_defined): NODE_IASGN is an assignment.
* ext/readline/readline.c (Readline.readline): use rl_outstream
and rl_instream. [ruby-dev:25699]
* ext/etc/etc.c (Init_etc): sGroup needs HAVE_ST_GR_PASSWD check
[ruby-dev:25675]
* misc/ruby-mode.el: [ruby-core:04415]
* lib/rdoc/generators/html_generator.rb: [ruby-core:04412]
* lib/rdoc/generators/ri_generator.rb: ditto.
* struct.c (make_struct): fixed: [ruby-core:04402]
* ext/curses/curses.c (window_color_set): [ruby-core:04393]
* ext/socket/socket.c (Init_socket): SO_REUSEPORT added.
[ruby-talk:130092]
* object.c: [ruby-doc:818]
* parse.y (open_args): fix too verbose warnings for the space
before argument parentheses. [ruby-dev:25492]
* parse.y (parser_yylex): ditto.
* parse.y (parser_yylex): the first expression in the parentheses
should not be a command. [ruby-dev:25492]
* lib/irb/context.rb (IRB::Context::initialize): [ruby-core:04330]
* object.c (Init_Object): remove Object#type. [ruby-core:04335]
* st.c (st_foreach): report success/failure by return value.
[ruby-Bugs-1396]
* parse.y: forgot to initialize parser struct. [ruby-dev:25492]
* parse.y (parser_yylex): no tLABEL on EXPR_BEG.
[ruby-talk:127711]
* document updates - [ruby-core:04296], [ruby-core:04301],
[ruby-core:04302], [ruby-core:04307]
* dir.c (rb_push_glob): should work for NUL delimited patterns.
* dir.c (rb_glob2): should aware of offset in the pattern.
* string.c (rb_str_new4): should propagate taintedness.
* env.h: rename member names in struct FRAME; last_func -> callee,
orig_func -> this_func, last_class -> this_class.
* struct.c (rb_struct_set): use original method name, not callee
name, to retrieve member slot. [ruby-core:04268]
* time.c (time_strftime): protect from format modification from GC
finalizers.
* object.c (Init_Object): remove rb_obj_id_obsolete()
* eval.c (rb_mod_define_method): incomplete subclass check.
[ruby-dev:25464]
* gc.c (rb_data_object_alloc): klass may be NULL.
[ruby-list:40498]
* bignum.c (rb_big_rand): should return positive random number.
[ruby-dev:25401]
* bignum.c (rb_big_rand): do not use rb_big_modulo to generate
random bignums. [ruby-dev:25396]
* variable.c (rb_autoload): [ruby-dev:25373]
* eval.c (svalue_to_avalue): [ruby-dev:25366]
* string.c (rb_str_justify): [ruby-dev:25367]
* io.c (rb_f_select): [ruby-dev:25312]
* ext/socket/socket.c (sock_s_getservbyport): [ruby-talk:124072]
* struct.c (make_struct): [ruby-dev:25249]
* dir.c (dir_open_dir): new function. [ruby-dev:25242]
* io.c (rb_f_open): add type check for return value from to_open.
* lib/pstore.rb (PStore#transaction): Use the empty content when a
file is not found. [ruby-dev:24561]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@8068 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-03-04 01:47:45 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
while nest > 0
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
|
|
|
nest -= 1 if TkRPAREN === tk
|
|
|
|
end
|
2010-04-01 03:45:16 -04:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
name
|
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Extracts a name or symbol from the token stream.
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def get_symbol_or_name
|
|
|
|
tk = get_tk
|
|
|
|
case tk
|
2010-04-01 03:45:16 -04:00
|
|
|
when TkSYMBOL then
|
|
|
|
text = tk.text.sub(/^:/, '')
|
|
|
|
|
|
|
|
if TkASSIGN === peek_tk then
|
|
|
|
get_tk
|
|
|
|
text << '='
|
|
|
|
end
|
|
|
|
|
|
|
|
text
|
|
|
|
when TkId, TkOp then
|
2008-07-17 20:46:16 -04:00
|
|
|
tk.name
|
2010-12-19 22:22:49 -05:00
|
|
|
when TkAMPER,
|
|
|
|
TkDSTRING,
|
|
|
|
TkSTAR,
|
|
|
|
TkSTRING then
|
2008-07-17 20:46:16 -04:00
|
|
|
tk.text
|
2008-01-13 22:34:05 -05:00
|
|
|
else
|
2010-04-01 03:45:16 -04:00
|
|
|
raise RDoc::Error, "Name or symbol expected (got #{tk})"
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
##
|
|
|
|
# Look for directives in a normal comment block:
|
|
|
|
#
|
2010-04-01 03:45:16 -04:00
|
|
|
# # :stopdoc:
|
|
|
|
# # Don't display comment from this point forward
|
2008-07-17 20:46:16 -04:00
|
|
|
#
|
2010-12-19 22:22:49 -05:00
|
|
|
# This routine modifies its +comment+ parameter.
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def look_for_directives_in(context, comment)
|
2010-04-10 02:36:13 -04:00
|
|
|
preprocess = RDoc::Markup::PreProcess.new @file_name, @options.rdoc_include
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-26 23:45:22 -04:00
|
|
|
preprocess.handle comment, context do |directive, param|
|
2008-07-17 20:46:16 -04:00
|
|
|
case directive
|
|
|
|
when 'enddoc' then
|
2010-12-19 22:22:49 -05:00
|
|
|
context.done_documenting = true
|
|
|
|
''
|
2008-07-17 20:46:16 -04:00
|
|
|
when 'main' then
|
2010-12-19 22:22:49 -05:00
|
|
|
@options.main_page = param if @options.respond_to? :main_page
|
2008-07-17 20:46:16 -04:00
|
|
|
''
|
2010-04-01 03:45:16 -04:00
|
|
|
when 'method', 'singleton-method',
|
|
|
|
'attr', 'attr_accessor', 'attr_reader', 'attr_writer' then
|
|
|
|
false # handled elsewhere
|
2008-07-17 20:46:16 -04:00
|
|
|
when 'section' then
|
2010-04-10 02:36:13 -04:00
|
|
|
context.set_current_section param, comment
|
2008-07-17 20:46:16 -04:00
|
|
|
comment.replace ''
|
|
|
|
break
|
|
|
|
when 'startdoc' then
|
|
|
|
context.start_doc
|
|
|
|
context.force_documentation = true
|
|
|
|
''
|
|
|
|
when 'stopdoc' then
|
|
|
|
context.stop_doc
|
|
|
|
''
|
|
|
|
when 'title' then
|
2010-12-19 22:22:49 -05:00
|
|
|
@options.default_title = param if @options.respond_to? :default_title=
|
2008-07-17 20:46:16 -04:00
|
|
|
''
|
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
remove_private_comments comment
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
##
|
|
|
|
# Adds useful info about the parser to +message+
|
|
|
|
|
|
|
|
def make_message message
|
2010-04-02 12:50:14 -04:00
|
|
|
prefix = "#{@file_name}:"
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
prefix << "#{@scanner.line_no}:#{@scanner.char_no}:" if @scanner
|
|
|
|
|
|
|
|
"#{prefix} #{message}"
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
##
|
|
|
|
# Creates an RDoc::Attr for the name following +tk+, setting the comment to
|
|
|
|
# +comment+.
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_attr(context, single, tk, comment)
|
2011-02-01 19:32:30 -05:00
|
|
|
offset = tk.seek
|
|
|
|
line_no = tk.line_no
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
args = parse_symbol_arg 1
|
2010-12-19 22:22:49 -05:00
|
|
|
if args.size > 0 then
|
2008-07-17 20:46:16 -04:00
|
|
|
name = args[0]
|
|
|
|
rw = "R"
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
if TkCOMMA === tk then
|
|
|
|
rw = "RW" if get_bool
|
2008-01-13 22:34:05 -05:00
|
|
|
else
|
2008-07-17 20:46:16 -04:00
|
|
|
unget_tk tk
|
|
|
|
end
|
2010-12-19 22:22:49 -05:00
|
|
|
|
|
|
|
att = RDoc::Attr.new get_tkread, name, rw, comment, single == SINGLE
|
|
|
|
att.record_location @top_level
|
2011-02-01 19:32:30 -05:00
|
|
|
att.offset = offset
|
|
|
|
att.line = line_no
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
read_documentation_modifiers att, RDoc::ATTR_MODIFIERS
|
2010-12-19 22:22:49 -05:00
|
|
|
|
|
|
|
context.add_attribute att if att.document_self
|
|
|
|
|
|
|
|
@stats.add_attribute att
|
2008-07-17 20:46:16 -04:00
|
|
|
else
|
2010-12-19 22:22:49 -05:00
|
|
|
warn "'attr' ignored - looks like a variable"
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
##
|
|
|
|
# Creates an RDoc::Attr for each attribute listed after +tk+, setting the
|
|
|
|
# comment for each to +comment+.
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_attr_accessor(context, single, tk, comment)
|
2011-02-01 19:32:30 -05:00
|
|
|
offset = tk.seek
|
|
|
|
line_no = tk.line_no
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
args = parse_symbol_arg
|
|
|
|
rw = "?"
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
tmp = RDoc::CodeObject.new
|
|
|
|
read_documentation_modifiers tmp, RDoc::ATTR_MODIFIERS
|
|
|
|
return unless tmp.document_self
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
case tk.name
|
|
|
|
when "attr_reader" then rw = "R"
|
|
|
|
when "attr_writer" then rw = "W"
|
|
|
|
when "attr_accessor" then rw = "RW"
|
|
|
|
else
|
2010-04-01 03:45:16 -04:00
|
|
|
rw = '?'
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
for name in args
|
2010-12-19 22:22:49 -05:00
|
|
|
att = RDoc::Attr.new get_tkread, name, rw, comment, single == SINGLE
|
|
|
|
att.record_location @top_level
|
2011-02-01 19:32:30 -05:00
|
|
|
att.offset = offset
|
|
|
|
att.line = line_no
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
context.add_attribute att
|
2010-12-19 22:22:49 -05:00
|
|
|
@stats.add_attribute att
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Parses an +alias+ in +context+ with +comment+
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_alias(context, single, tk, comment)
|
2011-02-01 19:32:30 -05:00
|
|
|
offset = tk.seek
|
|
|
|
line_no = tk.line_no
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
skip_tkspace
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
if TkLPAREN === peek_tk then
|
|
|
|
get_tk
|
|
|
|
skip_tkspace
|
|
|
|
end
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
new_name = get_symbol_or_name
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
@scanner.instance_eval { @lex_state = EXPR_FNAME }
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
skip_tkspace
|
|
|
|
if TkCOMMA === peek_tk then
|
|
|
|
get_tk
|
|
|
|
skip_tkspace
|
|
|
|
end
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
begin
|
|
|
|
old_name = get_symbol_or_name
|
|
|
|
rescue RDoc::Error
|
|
|
|
return
|
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
al = RDoc::Alias.new(get_tkread, old_name, new_name, comment,
|
|
|
|
single == SINGLE)
|
|
|
|
al.record_location @top_level
|
2011-02-01 19:32:30 -05:00
|
|
|
al.offset = offset
|
|
|
|
al.line = line_no
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
read_documentation_modifiers al, RDoc::ATTR_MODIFIERS
|
2010-04-01 03:45:16 -04:00
|
|
|
context.add_alias al if al.document_self
|
2010-12-19 22:22:49 -05:00
|
|
|
@stats.add_alias al
|
|
|
|
|
|
|
|
al
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Extracts call parameters from the token stream.
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_call_parameters(tk)
|
2008-01-13 22:34:05 -05:00
|
|
|
end_token = case tk
|
|
|
|
when TkLPAREN, TkfLPAREN
|
|
|
|
TkRPAREN
|
|
|
|
when TkRPAREN
|
|
|
|
return ""
|
|
|
|
else
|
|
|
|
TkNL
|
|
|
|
end
|
|
|
|
nest = 0
|
|
|
|
|
|
|
|
loop do
|
2010-04-01 03:45:16 -04:00
|
|
|
case tk
|
|
|
|
when TkSEMICOLON
|
|
|
|
break
|
|
|
|
when TkLPAREN, TkfLPAREN
|
|
|
|
nest += 1
|
|
|
|
when end_token
|
|
|
|
if end_token == TkRPAREN
|
|
|
|
nest -= 1
|
|
|
|
break if @scanner.lex_state == EXPR_END and nest <= 0
|
|
|
|
else
|
|
|
|
break unless @scanner.continue
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2010-08-29 10:54:16 -04:00
|
|
|
when TkCOMMENT, TkASSIGN, TkOPASGN
|
2010-04-01 03:45:16 -04:00
|
|
|
unget_tk(tk)
|
|
|
|
break
|
|
|
|
when nil then
|
|
|
|
break
|
|
|
|
end
|
|
|
|
tk = get_tk
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
res = get_tkread.tr("\n", " ").strip
|
|
|
|
res = "" if res == ";"
|
|
|
|
res
|
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Parses a class in +context+ with +comment+
|
|
|
|
|
2008-07-21 14:35:14 -04:00
|
|
|
def parse_class(container, single, tk, comment)
|
2011-02-01 19:32:30 -05:00
|
|
|
offset = tk.seek
|
|
|
|
line_no = tk.line_no
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
declaration_context = container
|
|
|
|
container, name_t, given_name = get_class_or_module container
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
case name_t
|
|
|
|
when TkCONSTANT
|
|
|
|
name = name_t.name
|
2010-12-19 22:22:49 -05:00
|
|
|
superclass = '::Object'
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
if TkLT === peek_tk then
|
|
|
|
get_tk
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace
|
2008-07-17 20:46:16 -04:00
|
|
|
superclass = get_class_specification
|
2010-12-19 22:22:49 -05:00
|
|
|
superclass = '(unknown)' if superclass.empty?
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
|
|
|
|
2008-07-21 14:35:14 -04:00
|
|
|
cls_type = single == SINGLE ? RDoc::SingleClass : RDoc::NormalClass
|
2010-12-19 22:22:49 -05:00
|
|
|
cls = declaration_context.add_class cls_type, given_name, superclass
|
2008-07-21 14:35:14 -04:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
read_documentation_modifiers cls, RDoc::CLASS_MODIFIERS
|
2008-07-21 14:35:14 -04:00
|
|
|
cls.record_location @top_level
|
2011-02-01 19:32:30 -05:00
|
|
|
cls.offset = offset
|
|
|
|
cls.line = line_no
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
cls.comment = comment if cls.document_self
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
@top_level.add_to_classes_or_modules cls
|
2010-04-01 03:45:16 -04:00
|
|
|
@stats.add_class cls
|
|
|
|
|
|
|
|
parse_statements cls
|
2008-07-17 20:46:16 -04:00
|
|
|
when TkLSHFT
|
|
|
|
case name = get_class_specification
|
|
|
|
when "self", container.name
|
2010-04-01 03:45:16 -04:00
|
|
|
parse_statements container, SINGLE
|
2010-12-19 22:22:49 -05:00
|
|
|
else
|
2010-04-01 03:45:16 -04:00
|
|
|
other = RDoc::TopLevel.find_class_named name
|
|
|
|
|
|
|
|
unless other then
|
|
|
|
other = container.add_module RDoc::NormalModule, name
|
|
|
|
other.record_location @top_level
|
2011-02-01 19:32:30 -05:00
|
|
|
other.offset = offset
|
|
|
|
other.line = line_no
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
other.comment = comment
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2008-07-21 14:35:14 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
# notify :nodoc: all if not a constant-named class/module
|
|
|
|
# (and remove any comment)
|
|
|
|
unless name =~ /\A(::)?[A-Z]/
|
|
|
|
other.document_self = nil
|
|
|
|
other.document_children = false
|
|
|
|
other.clear_comment
|
|
|
|
end
|
|
|
|
|
|
|
|
@top_level.add_to_classes_or_modules other
|
2008-07-21 14:35:14 -04:00
|
|
|
@stats.add_class other
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
read_documentation_modifiers other, RDoc::CLASS_MODIFIERS
|
2008-07-21 14:35:14 -04:00
|
|
|
parse_statements(other, SINGLE)
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
else
|
|
|
|
warn("Expected class name or '<<'. Got #{name_t.class}: #{name_t.text.inspect}")
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Parses a constant in +context+ with +comment+
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
def parse_constant(container, tk, comment)
|
2011-02-01 19:32:30 -05:00
|
|
|
offset = tk.seek
|
|
|
|
line_no = tk.line_no
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
name = tk.name
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2010-12-19 22:22:49 -05:00
|
|
|
|
|
|
|
return unless name =~ /^\w+$/
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
eq_tk = get_tk
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
unless TkASSIGN === eq_tk then
|
2010-04-01 03:45:16 -04:00
|
|
|
unget_tk eq_tk
|
2011-02-01 19:32:30 -05:00
|
|
|
return false
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
nest = 0
|
2008-07-17 20:46:16 -04:00
|
|
|
get_tkread
|
|
|
|
|
|
|
|
tk = get_tk
|
2010-04-01 03:45:16 -04:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
if TkGT === tk then
|
2010-04-01 03:45:16 -04:00
|
|
|
unget_tk tk
|
|
|
|
unget_tk eq_tk
|
2011-02-01 19:32:30 -05:00
|
|
|
return false
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
rhs_name = ''
|
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
loop do
|
2010-04-01 03:45:16 -04:00
|
|
|
case tk
|
|
|
|
when TkSEMICOLON then
|
2010-12-19 22:22:49 -05:00
|
|
|
break if nest <= 0
|
|
|
|
when TkLPAREN, TkfLPAREN, TkLBRACE, TkfLBRACE, TkLBRACK, TkfLBRACK,
|
|
|
|
TkDO, TkIF, TkUNLESS, TkCASE, TkDEF, TkBEGIN then
|
2010-04-01 03:45:16 -04:00
|
|
|
nest += 1
|
|
|
|
when TkRPAREN, TkRBRACE, TkRBRACK, TkEND then
|
|
|
|
nest -= 1
|
|
|
|
when TkCOMMENT then
|
|
|
|
if nest <= 0 && @scanner.lex_state == EXPR_END
|
|
|
|
unget_tk tk
|
2003-12-01 02:12:49 -05:00
|
|
|
break
|
|
|
|
end
|
2010-04-01 03:45:16 -04:00
|
|
|
when TkCONSTANT then
|
|
|
|
rhs_name << tk.name
|
|
|
|
|
|
|
|
if nest <= 0 and TkNL === peek_tk then
|
|
|
|
mod = if rhs_name =~ /^::/ then
|
|
|
|
RDoc::TopLevel.find_class_or_module rhs_name
|
|
|
|
else
|
|
|
|
container.find_module_named rhs_name
|
|
|
|
end
|
|
|
|
|
2011-02-01 19:32:30 -05:00
|
|
|
container.add_module_alias mod, name, @top_level if mod
|
2010-04-01 03:45:16 -04:00
|
|
|
get_tk # TkNL
|
|
|
|
break
|
|
|
|
end
|
|
|
|
when TkNL then
|
|
|
|
if nest <= 0 &&
|
|
|
|
(@scanner.lex_state == EXPR_END || !@scanner.continue) then
|
|
|
|
unget_tk tk
|
|
|
|
break
|
|
|
|
end
|
|
|
|
when TkCOLON2, TkCOLON3 then
|
|
|
|
rhs_name << '::'
|
|
|
|
when nil then
|
|
|
|
break
|
|
|
|
end
|
|
|
|
tk = get_tk
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
res = get_tkread.gsub(/^[ \t]+/, '').strip
|
2008-01-13 22:34:05 -05:00
|
|
|
res = "" if res == ";"
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
con = RDoc::Constant.new name, res, comment
|
2010-12-19 22:22:49 -05:00
|
|
|
con.record_location @top_level
|
2011-02-01 19:32:30 -05:00
|
|
|
con.offset = offset
|
|
|
|
con.line = line_no
|
2008-07-17 20:46:16 -04:00
|
|
|
read_documentation_modifiers con, RDoc::CONSTANT_MODIFIERS
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
@stats.add_constant con
|
|
|
|
container.add_constant con if con.document_self
|
2011-02-01 19:32:30 -05:00
|
|
|
true
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
##
|
|
|
|
# Generates an RDoc::Method or RDoc::Attr from +comment+ by looking for
|
|
|
|
# :method: or :attr: directives in +comment+.
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_comment(container, tk, comment)
|
|
|
|
column = tk.char_no
|
2011-02-01 19:32:30 -05:00
|
|
|
offset = tk.seek
|
|
|
|
line_no = tk.line_no
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
singleton = !!comment.sub!(/(^# +:?)(singleton-)(method:)/, '\1\3')
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
# REFACTOR
|
2008-07-17 20:46:16 -04:00
|
|
|
if comment.sub!(/^# +:?method: *(\S*).*?\n/i, '') then
|
|
|
|
name = $1 unless $1.empty?
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
meth = RDoc::GhostMethod.new get_tkread, name
|
2010-12-19 22:22:49 -05:00
|
|
|
meth.record_location @top_level
|
2010-04-01 03:45:16 -04:00
|
|
|
meth.singleton = singleton
|
2011-02-01 19:32:30 -05:00
|
|
|
meth.offset = offset
|
|
|
|
meth.line = line_no
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
meth.start_collecting_tokens
|
|
|
|
indent = TkSPACE.new nil, 1, 1
|
|
|
|
indent.set_text " " * column
|
2008-07-21 14:35:14 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
position_comment = TkCOMMENT.new nil, line_no, 1
|
|
|
|
position_comment.set_text "# File #{@top_level.absolute_name}, line #{line_no}"
|
|
|
|
meth.add_tokens [position_comment, NEWLINE_TOKEN, indent]
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
meth.params = ''
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
extract_call_seq comment, meth
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
return unless meth.name
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
container.add_method meth if meth.document_self
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
meth.comment = comment
|
|
|
|
|
|
|
|
@stats.add_method meth
|
2011-02-01 19:32:30 -05:00
|
|
|
elsif comment.sub!(/# +:?(attr(_reader|_writer|_accessor)?): *(\S*).*?\n/i, '') then
|
2010-04-01 03:45:16 -04:00
|
|
|
rw = case $1
|
|
|
|
when 'attr_reader' then 'R'
|
|
|
|
when 'attr_writer' then 'W'
|
|
|
|
else 'RW'
|
|
|
|
end
|
|
|
|
|
|
|
|
name = $3 unless $3.empty?
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
# TODO authorize 'singleton-attr...'?
|
2010-04-01 03:45:16 -04:00
|
|
|
att = RDoc::Attr.new get_tkread, name, rw, comment
|
2010-12-19 22:22:49 -05:00
|
|
|
att.record_location @top_level
|
2011-02-01 19:32:30 -05:00
|
|
|
att.offset = offset
|
|
|
|
att.line = line_no
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
container.add_attribute att
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
@stats.add_attribute att
|
2010-04-01 03:45:16 -04:00
|
|
|
end
|
2010-12-28 17:08:56 -05:00
|
|
|
|
|
|
|
true
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Parses an +include+ in +context+ with +comment+
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_include(context, comment)
|
|
|
|
loop do
|
|
|
|
skip_tkspace_comment
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
name = get_constant_with_optional_parens
|
|
|
|
context.add_include RDoc::Include.new(name, comment) unless name.empty?
|
|
|
|
|
|
|
|
return unless TkCOMMA === peek_tk
|
|
|
|
get_tk
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
##
|
|
|
|
# Parses a meta-programmed attribute and creates an RDoc::Attr.
|
|
|
|
#
|
|
|
|
# To create foo and bar attributes on class C with comment "My attributes":
|
|
|
|
#
|
|
|
|
# class C
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2010-04-01 03:45:16 -04:00
|
|
|
# ##
|
|
|
|
# # :attr:
|
|
|
|
# #
|
|
|
|
# # My attributes
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2010-04-01 03:45:16 -04:00
|
|
|
# my_attr :foo, :bar
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2010-04-01 03:45:16 -04:00
|
|
|
# end
|
|
|
|
#
|
|
|
|
# To create a foo attribute on class C with comment "My attribute":
|
|
|
|
#
|
|
|
|
# class C
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2010-04-01 03:45:16 -04:00
|
|
|
# ##
|
|
|
|
# # :attr: foo
|
|
|
|
# #
|
|
|
|
# # My attribute
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2010-04-01 03:45:16 -04:00
|
|
|
# my_attr :foo, :bar
|
2010-04-02 00:40:47 -04:00
|
|
|
#
|
2010-04-01 03:45:16 -04:00
|
|
|
# end
|
|
|
|
|
|
|
|
def parse_meta_attr(context, single, tk, comment)
|
|
|
|
args = parse_symbol_arg
|
|
|
|
rw = "?"
|
|
|
|
|
|
|
|
# If nodoc is given, don't document any of them
|
|
|
|
|
|
|
|
tmp = RDoc::CodeObject.new
|
|
|
|
read_documentation_modifiers tmp, RDoc::ATTR_MODIFIERS
|
|
|
|
return unless tmp.document_self
|
|
|
|
|
|
|
|
if comment.sub!(/^# +:?(attr(_reader|_writer|_accessor)?): *(\S*).*?\n/i, '') then
|
|
|
|
rw = case $1
|
|
|
|
when 'attr_reader' then 'R'
|
|
|
|
when 'attr_writer' then 'W'
|
|
|
|
else 'RW'
|
|
|
|
end
|
|
|
|
name = $3 unless $3.empty?
|
|
|
|
end
|
|
|
|
|
|
|
|
if name then
|
2010-12-19 22:22:49 -05:00
|
|
|
att = RDoc::Attr.new get_tkread, name, rw, comment, single == SINGLE
|
|
|
|
att.record_location @top_level
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
context.add_attribute att
|
2010-12-19 22:22:49 -05:00
|
|
|
@stats.add_attribute att
|
2010-04-01 03:45:16 -04:00
|
|
|
else
|
|
|
|
args.each do |attr_name|
|
2010-12-19 22:22:49 -05:00
|
|
|
att = RDoc::Attr.new(get_tkread, attr_name, rw, comment,
|
|
|
|
single == SINGLE)
|
|
|
|
att.record_location @top_level
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
context.add_attribute att
|
2010-12-19 22:22:49 -05:00
|
|
|
@stats.add_attribute att
|
2010-04-01 03:45:16 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
##
|
|
|
|
# Parses a meta-programmed method
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_meta_method(container, single, tk, comment)
|
|
|
|
column = tk.char_no
|
2011-02-01 19:32:30 -05:00
|
|
|
offset = tk.seek
|
|
|
|
line_no = tk.line_no
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
start_collecting_tokens
|
|
|
|
add_token tk
|
|
|
|
add_token_listener self
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
skip_tkspace false
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
singleton = !!comment.sub!(/(^# +:?)(singleton-)(method:)/, '\1\3')
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
if comment.sub!(/^# +:?method: *(\S*).*?\n/i, '') then
|
|
|
|
name = $1 unless $1.empty?
|
|
|
|
end
|
|
|
|
|
|
|
|
if name.nil? then
|
|
|
|
name_t = get_tk
|
|
|
|
case name_t
|
|
|
|
when TkSYMBOL then
|
|
|
|
name = name_t.text[1..-1]
|
|
|
|
when TkSTRING then
|
2010-04-01 03:45:16 -04:00
|
|
|
name = name_t.value[1..-2]
|
|
|
|
when TkASSIGN then # ignore
|
|
|
|
remove_token_listener self
|
|
|
|
return
|
2008-07-17 20:46:16 -04:00
|
|
|
else
|
2010-04-01 03:45:16 -04:00
|
|
|
warn "unknown name token #{name_t.inspect} for meta-method '#{tk.name}'"
|
2008-07-17 20:46:16 -04:00
|
|
|
name = 'unknown'
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
meth = RDoc::MetaMethod.new get_tkread, name
|
2010-12-19 22:22:49 -05:00
|
|
|
meth.record_location @top_level
|
2011-02-01 19:32:30 -05:00
|
|
|
meth.offset = offset
|
|
|
|
meth.line = line_no
|
2008-07-17 20:46:16 -04:00
|
|
|
meth.singleton = singleton
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
remove_token_listener self
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
meth.start_collecting_tokens
|
2010-04-01 03:45:16 -04:00
|
|
|
indent = TkSPACE.new nil, 1, 1
|
2008-07-17 20:46:16 -04:00
|
|
|
indent.set_text " " * column
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
position_comment = TkCOMMENT.new nil, line_no, 1
|
|
|
|
position_comment.value = "# File #{@top_level.absolute_name}, line #{line_no}"
|
2008-07-17 20:46:16 -04:00
|
|
|
meth.add_tokens [position_comment, NEWLINE_TOKEN, indent]
|
|
|
|
meth.add_tokens @token_stream
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
token_listener meth do
|
|
|
|
meth.params = ''
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
extract_call_seq comment, meth
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
container.add_method meth if meth.document_self
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
last_tk = tk
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
while tk = get_tk do
|
|
|
|
case tk
|
|
|
|
when TkSEMICOLON then
|
|
|
|
break
|
|
|
|
when TkNL then
|
|
|
|
break unless last_tk and TkCOMMA === last_tk
|
|
|
|
when TkSPACE then
|
|
|
|
# expression continues
|
2011-02-01 19:32:30 -05:00
|
|
|
when TkDO then
|
|
|
|
unget_tk tk
|
|
|
|
parse_statements container, single, meth
|
|
|
|
break
|
2010-04-01 03:45:16 -04:00
|
|
|
else
|
|
|
|
last_tk = tk
|
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
meth.comment = comment
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
@stats.add_method meth
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
##
|
2010-04-01 03:45:16 -04:00
|
|
|
# Parses a normal method defined by +def+
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_method(container, single, tk, comment)
|
2010-04-01 03:45:16 -04:00
|
|
|
added_container = nil
|
|
|
|
meth = nil
|
|
|
|
name = nil
|
2008-07-17 20:46:16 -04:00
|
|
|
column = tk.char_no
|
2011-02-01 19:32:30 -05:00
|
|
|
offset = tk.seek
|
|
|
|
line_no = tk.line_no
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
start_collecting_tokens
|
2010-04-01 03:45:16 -04:00
|
|
|
add_token tk
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
token_listener self do
|
|
|
|
@scanner.instance_eval do @lex_state = EXPR_FNAME end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
skip_tkspace
|
2010-04-01 03:45:16 -04:00
|
|
|
name_t = get_tk
|
|
|
|
back_tk = skip_tkspace
|
|
|
|
meth = nil
|
|
|
|
added_container = false
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
dot = get_tk
|
|
|
|
if TkDOT === dot or TkCOLON2 === dot then
|
|
|
|
@scanner.instance_eval do @lex_state = EXPR_FNAME end
|
|
|
|
skip_tkspace
|
|
|
|
name_t2 = get_tk
|
|
|
|
|
|
|
|
case name_t
|
|
|
|
when TkSELF, TkMOD then
|
|
|
|
name = name_t2.name
|
|
|
|
when TkCONSTANT then
|
|
|
|
name = name_t2.name
|
|
|
|
prev_container = container
|
|
|
|
container = container.find_module_named(name_t.name)
|
|
|
|
unless container then
|
|
|
|
added_container = true
|
|
|
|
obj = name_t.name.split("::").inject(Object) do |state, item|
|
|
|
|
state.const_get(item)
|
|
|
|
end rescue nil
|
|
|
|
|
|
|
|
type = obj.class == Class ? RDoc::NormalClass : RDoc::NormalModule
|
|
|
|
|
|
|
|
unless [Class, Module].include?(obj.class) then
|
|
|
|
warn("Couldn't find #{name_t.name}. Assuming it's a module")
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
if type == RDoc::NormalClass then
|
|
|
|
sclass = obj.superclass ? obj.superclass.name : nil
|
|
|
|
container = prev_container.add_class type, name_t.name, sclass
|
|
|
|
else
|
|
|
|
container = prev_container.add_module type, name_t.name
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
container.record_location @top_level
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2010-12-19 22:22:49 -05:00
|
|
|
when TkIDENTIFIER, TkIVAR, TkGVAR then
|
2010-04-01 03:45:16 -04:00
|
|
|
dummy = RDoc::Context.new
|
|
|
|
dummy.parent = container
|
|
|
|
skip_method dummy
|
|
|
|
return
|
2010-12-19 22:22:49 -05:00
|
|
|
when TkTRUE, TkFALSE, TkNIL then
|
|
|
|
klass_name = "#{name_t.name.capitalize}Class"
|
|
|
|
container = RDoc::TopLevel.find_class_named klass_name
|
|
|
|
container ||= @top_level.add_class RDoc::NormalClass, klass_name
|
|
|
|
|
|
|
|
name = name_t2.name
|
2010-04-01 03:45:16 -04:00
|
|
|
else
|
|
|
|
warn "unexpected method name token #{name_t.inspect}"
|
|
|
|
# break
|
|
|
|
skip_method container
|
|
|
|
return
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
meth = RDoc::AnyMethod.new(get_tkread, name)
|
|
|
|
meth.singleton = true
|
2008-07-17 20:46:16 -04:00
|
|
|
else
|
2010-04-01 03:45:16 -04:00
|
|
|
unget_tk dot
|
|
|
|
back_tk.reverse_each do |token|
|
|
|
|
unget_tk token
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
name = case name_t
|
|
|
|
when TkSTAR, TkAMPER then
|
|
|
|
name_t.text
|
|
|
|
else
|
|
|
|
unless name_t.respond_to? :name then
|
|
|
|
warn "expected method name token, . or ::, got #{name_t.inspect}"
|
|
|
|
skip_method container
|
|
|
|
return
|
|
|
|
end
|
|
|
|
name_t.name
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
meth = RDoc::AnyMethod.new get_tkread, name
|
|
|
|
meth.singleton = (single == SINGLE)
|
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
meth.record_location @top_level
|
2011-02-01 19:32:30 -05:00
|
|
|
meth.offset = offset
|
|
|
|
meth.line = line_no
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
meth.start_collecting_tokens
|
2010-04-01 03:45:16 -04:00
|
|
|
indent = TkSPACE.new nil, 1, 1
|
2008-07-17 20:46:16 -04:00
|
|
|
indent.set_text " " * column
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
token = TkCOMMENT.new nil, line_no, 1
|
|
|
|
token.set_text "# File #{@top_level.absolute_name}, line #{line_no}"
|
2008-07-17 20:46:16 -04:00
|
|
|
meth.add_tokens [token, NEWLINE_TOKEN, indent]
|
|
|
|
meth.add_tokens @token_stream
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
token_listener meth do
|
|
|
|
@scanner.instance_eval do @continue = false end
|
|
|
|
parse_method_parameters meth
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
if meth.document_self then
|
|
|
|
container.add_method meth
|
|
|
|
elsif added_container then
|
|
|
|
container.document_self = false
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
# Having now read the method parameters and documentation modifiers, we
|
|
|
|
# now know whether we have to rename #initialize to ::new
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
if name == "initialize" && !meth.singleton then
|
|
|
|
if meth.dont_rename_initialize then
|
|
|
|
meth.visibility = :protected
|
|
|
|
else
|
|
|
|
meth.singleton = true
|
|
|
|
meth.name = "new"
|
|
|
|
meth.visibility = :public
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
parse_statements container, single, meth
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
extract_call_seq comment, meth
|
|
|
|
|
|
|
|
meth.comment = comment
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
@stats.add_method meth
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Extracts +yield+ parameters from +method+
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_method_or_yield_parameters(method = nil,
|
|
|
|
modifiers = RDoc::METHOD_MODIFIERS)
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
|
|
|
|
|
|
|
# Little hack going on here. In the statement
|
|
|
|
# f = 2*(1+yield)
|
|
|
|
# We see the RPAREN as the next token, so we need
|
|
|
|
# to exit early. This still won't catch all cases
|
|
|
|
# (such as "a = yield + 1"
|
|
|
|
end_token = case tk
|
|
|
|
when TkLPAREN, TkfLPAREN
|
|
|
|
TkRPAREN
|
|
|
|
when TkRPAREN
|
|
|
|
return ""
|
|
|
|
else
|
|
|
|
TkNL
|
|
|
|
end
|
|
|
|
nest = 0
|
|
|
|
|
|
|
|
loop do
|
2010-04-01 03:45:16 -04:00
|
|
|
case tk
|
|
|
|
when TkSEMICOLON then
|
2010-12-19 22:22:49 -05:00
|
|
|
break if nest == 0
|
|
|
|
when TkLBRACE, TkfLBRACE then
|
2010-04-01 03:45:16 -04:00
|
|
|
nest += 1
|
|
|
|
when TkRBRACE then
|
|
|
|
nest -= 1
|
2010-12-19 22:22:49 -05:00
|
|
|
if nest <= 0
|
|
|
|
# we might have a.each { |i| yield i }
|
|
|
|
unget_tk(tk) if nest < 0
|
|
|
|
break
|
|
|
|
end
|
2010-04-01 03:45:16 -04:00
|
|
|
when TkLPAREN, TkfLPAREN then
|
|
|
|
nest += 1
|
|
|
|
when end_token then
|
|
|
|
if end_token == TkRPAREN
|
2008-07-17 20:46:16 -04:00
|
|
|
nest -= 1
|
2010-04-01 03:45:16 -04:00
|
|
|
break if @scanner.lex_state == EXPR_END and nest <= 0
|
|
|
|
else
|
|
|
|
break unless @scanner.continue
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2010-12-19 22:22:49 -05:00
|
|
|
when TkRPAREN then
|
|
|
|
nest -= 1
|
2010-04-01 03:45:16 -04:00
|
|
|
when method && method.block_params.nil? && TkCOMMENT then
|
|
|
|
unget_tk tk
|
|
|
|
read_documentation_modifiers method, modifiers
|
|
|
|
@read.pop
|
|
|
|
when TkCOMMENT then
|
|
|
|
@read.pop
|
|
|
|
when nil then
|
|
|
|
break
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
|
|
|
end
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
res = get_tkread.gsub(/\s+/, ' ').strip
|
|
|
|
res = '' if res == ';'
|
2008-07-17 20:46:16 -04:00
|
|
|
res
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
##
|
|
|
|
# Capture the method's parameters. Along the way, look for a comment
|
|
|
|
# containing:
|
|
|
|
#
|
|
|
|
# # yields: ....
|
|
|
|
#
|
|
|
|
# and add this as the block_params for the method
|
|
|
|
|
|
|
|
def parse_method_parameters(method)
|
2010-04-01 03:45:16 -04:00
|
|
|
res = parse_method_or_yield_parameters method
|
|
|
|
|
|
|
|
res = "(#{res})" unless res =~ /\A\(/
|
2008-07-17 20:46:16 -04:00
|
|
|
method.params = res unless method.params
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
if method.block_params.nil? then
|
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
read_documentation_modifiers method, RDoc::METHOD_MODIFIERS
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Parses an RDoc::NormalModule in +container+ with +comment+
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_module(container, single, tk, comment)
|
2010-12-19 22:22:49 -05:00
|
|
|
container, name_t, = get_class_or_module container
|
2008-07-21 14:35:14 -04:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
name = name_t.name
|
|
|
|
|
|
|
|
mod = container.add_module RDoc::NormalModule, name
|
|
|
|
mod.record_location @top_level
|
2008-07-21 14:35:14 -04:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
read_documentation_modifiers mod, RDoc::CLASS_MODIFIERS
|
2010-12-19 22:22:49 -05:00
|
|
|
mod.comment = comment if mod.document_self
|
2008-07-17 20:46:16 -04:00
|
|
|
parse_statements(mod)
|
2010-04-01 03:45:16 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
@top_level.add_to_classes_or_modules mod
|
2010-04-01 03:45:16 -04:00
|
|
|
@stats.add_module mod
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Parses an RDoc::Require in +context+ containing +comment+
|
|
|
|
|
2003-12-01 02:12:49 -05:00
|
|
|
def parse_require(context, comment)
|
|
|
|
skip_tkspace_comment
|
|
|
|
tk = get_tk
|
2010-04-01 03:45:16 -04:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
if TkLPAREN === tk then
|
2003-12-01 02:12:49 -05:00
|
|
|
skip_tkspace_comment
|
|
|
|
tk = get_tk
|
|
|
|
end
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
name = tk.text if TkSTRING === tk
|
|
|
|
|
|
|
|
if name then
|
2010-12-19 22:22:49 -05:00
|
|
|
@top_level.add_require RDoc::Require.new(name, comment)
|
2004-10-09 23:35:51 -04:00
|
|
|
else
|
2010-04-01 03:45:16 -04:00
|
|
|
unget_tk tk
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
##
|
|
|
|
# The core of the ruby parser.
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_statements(container, single = NORMAL, current_method = nil,
|
|
|
|
comment = '')
|
2011-02-01 19:32:30 -05:00
|
|
|
comment.force_encoding @encoding if @encoding
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
nest = 1
|
|
|
|
save_visibility = container.visibility
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
non_comment_seen = true
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
while tk = get_tk do
|
|
|
|
keep_comment = false
|
2011-02-01 19:32:30 -05:00
|
|
|
try_parse_comment = false
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
non_comment_seen = true unless TkCOMMENT === tk
|
|
|
|
|
|
|
|
case tk
|
|
|
|
when TkNL then
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
|
|
|
|
|
|
|
if TkCOMMENT === tk then
|
|
|
|
if non_comment_seen then
|
|
|
|
# Look for RDoc in a comment about to be thrown away
|
2010-12-28 17:08:56 -05:00
|
|
|
non_comment_seen = parse_comment container, tk, comment unless
|
|
|
|
comment.empty?
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
comment = ''
|
2011-02-01 19:32:30 -05:00
|
|
|
comment.force_encoding @encoding if @encoding
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
while TkCOMMENT === tk do
|
|
|
|
comment << tk.text << "\n"
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
tk = get_tk # this is the newline
|
|
|
|
skip_tkspace false # leading spaces
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
unless comment.empty? then
|
|
|
|
look_for_directives_in container, comment
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
if container.done_documenting then
|
|
|
|
container.ongoing_visibility = save_visibility
|
|
|
|
end
|
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
keep_comment = true
|
|
|
|
else
|
|
|
|
non_comment_seen = true
|
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
unget_tk tk
|
|
|
|
keep_comment = true
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
when TkCLASS then
|
|
|
|
if container.document_children then
|
|
|
|
parse_class container, single, tk, comment
|
|
|
|
else
|
|
|
|
nest += 1
|
|
|
|
end
|
|
|
|
|
|
|
|
when TkMODULE then
|
|
|
|
if container.document_children then
|
|
|
|
parse_module container, single, tk, comment
|
|
|
|
else
|
|
|
|
nest += 1
|
|
|
|
end
|
|
|
|
|
|
|
|
when TkDEF then
|
|
|
|
if container.document_self then
|
|
|
|
parse_method container, single, tk, comment
|
|
|
|
else
|
|
|
|
nest += 1
|
|
|
|
end
|
|
|
|
|
|
|
|
when TkCONSTANT then
|
|
|
|
if container.document_self then
|
2011-02-01 19:32:30 -05:00
|
|
|
if not parse_constant container, tk, comment then
|
|
|
|
try_parse_comment = true
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
when TkALIAS then
|
2010-04-01 03:45:16 -04:00
|
|
|
if container.document_self and not current_method then
|
2008-07-17 20:46:16 -04:00
|
|
|
parse_alias container, single, tk, comment
|
|
|
|
end
|
|
|
|
|
|
|
|
when TkYIELD then
|
|
|
|
if current_method.nil? then
|
|
|
|
warn "Warning: yield outside of method" if container.document_self
|
|
|
|
else
|
|
|
|
parse_yield container, single, tk, current_method
|
|
|
|
end
|
|
|
|
|
|
|
|
# Until and While can have a 'do', which shouldn't increase the nesting.
|
|
|
|
# We can't solve the general case, but we can handle most occurrences by
|
|
|
|
# ignoring a do at the end of a line.
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
when TkUNTIL, TkWHILE then
|
2008-07-17 20:46:16 -04:00
|
|
|
nest += 1
|
|
|
|
skip_optional_do_after_expression
|
|
|
|
|
|
|
|
# 'for' is trickier
|
|
|
|
when TkFOR then
|
|
|
|
nest += 1
|
|
|
|
skip_for_variable
|
|
|
|
skip_optional_do_after_expression
|
|
|
|
|
|
|
|
when TkCASE, TkDO, TkIF, TkUNLESS, TkBEGIN then
|
|
|
|
nest += 1
|
|
|
|
|
|
|
|
when TkIDENTIFIER then
|
|
|
|
if nest == 1 and current_method.nil? then
|
|
|
|
case tk.name
|
|
|
|
when 'private', 'protected', 'public', 'private_class_method',
|
|
|
|
'public_class_method', 'module_function' then
|
|
|
|
parse_visibility container, single, tk
|
|
|
|
keep_comment = true
|
|
|
|
when 'attr' then
|
|
|
|
parse_attr container, single, tk, comment
|
2010-04-01 03:45:16 -04:00
|
|
|
when /^attr_(reader|writer|accessor)$/ then
|
2008-07-17 20:46:16 -04:00
|
|
|
parse_attr_accessor container, single, tk, comment
|
|
|
|
when 'alias_method' then
|
2010-04-01 03:45:16 -04:00
|
|
|
parse_alias container, single, tk, comment if
|
|
|
|
container.document_self
|
|
|
|
when 'require', 'include' then
|
|
|
|
# ignore
|
2008-07-17 20:46:16 -04:00
|
|
|
else
|
|
|
|
if container.document_self and comment =~ /\A#\#$/ then
|
2010-04-01 03:45:16 -04:00
|
|
|
case comment
|
|
|
|
when /^# +:?attr(_reader|_writer|_accessor)?:/ then
|
|
|
|
parse_meta_attr container, single, tk, comment
|
|
|
|
else
|
|
|
|
parse_meta_method container, single, tk, comment
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
case tk.name
|
|
|
|
when "require" then
|
|
|
|
parse_require container, comment
|
|
|
|
when "include" then
|
|
|
|
parse_include container, comment
|
|
|
|
end
|
|
|
|
|
|
|
|
when TkEND then
|
|
|
|
nest -= 1
|
|
|
|
if nest == 0 then
|
|
|
|
read_documentation_modifiers container, RDoc::CLASS_MODIFIERS
|
|
|
|
container.ongoing_visibility = save_visibility
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
parse_comment container, tk, comment unless comment.empty?
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
return
|
|
|
|
end
|
2010-12-28 17:08:56 -05:00
|
|
|
else
|
2011-02-01 19:32:30 -05:00
|
|
|
try_parse_comment = nest == 1
|
|
|
|
end
|
|
|
|
|
|
|
|
if try_parse_comment then
|
2010-12-28 17:08:56 -05:00
|
|
|
non_comment_seen = parse_comment container, tk, comment unless
|
|
|
|
comment.empty?
|
|
|
|
|
2011-02-01 19:32:30 -05:00
|
|
|
keep_comment = false
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
|
2011-02-01 19:32:30 -05:00
|
|
|
unless keep_comment then
|
|
|
|
comment = ''
|
|
|
|
comment.force_encoding @encoding if @encoding
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
begin
|
|
|
|
get_tkread
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
end while peek_tk == TkNL
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2008-01-13 22:34:05 -05:00
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Parse up to +no+ symbol arguments
|
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
def parse_symbol_arg(no = nil)
|
|
|
|
args = []
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
skip_tkspace_comment
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
case tk = get_tk
|
|
|
|
when TkLPAREN
|
|
|
|
loop do
|
|
|
|
skip_tkspace_comment
|
|
|
|
if tk1 = parse_symbol_in_arg
|
|
|
|
args.push tk1
|
|
|
|
break if no and args.size >= no
|
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
skip_tkspace_comment
|
|
|
|
case tk2 = get_tk
|
|
|
|
when TkRPAREN
|
|
|
|
break
|
|
|
|
when TkCOMMA
|
|
|
|
else
|
|
|
|
warn("unexpected token: '#{tk2.inspect}'") if $DEBUG_RDOC
|
|
|
|
break
|
|
|
|
end
|
|
|
|
end
|
|
|
|
else
|
|
|
|
unget_tk tk
|
|
|
|
if tk = parse_symbol_in_arg
|
|
|
|
args.push tk
|
|
|
|
return args if no and args.size >= no
|
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
loop do
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
tk1 = get_tk
|
2008-07-17 20:46:16 -04:00
|
|
|
unless TkCOMMA === tk1 then
|
2008-01-13 22:34:05 -05:00
|
|
|
unget_tk tk1
|
|
|
|
break
|
|
|
|
end
|
|
|
|
|
|
|
|
skip_tkspace_comment
|
|
|
|
if tk = parse_symbol_in_arg
|
|
|
|
args.push tk
|
|
|
|
break if no and args.size >= no
|
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
|
|
|
end
|
2010-12-19 22:22:49 -05:00
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
args
|
|
|
|
end
|
2003-12-01 02:12:49 -05:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Returns symbol text from the next token
|
|
|
|
|
2008-01-13 22:34:05 -05:00
|
|
|
def parse_symbol_in_arg
|
|
|
|
case tk = get_tk
|
|
|
|
when TkSYMBOL
|
|
|
|
tk.text.sub(/^:/, '')
|
|
|
|
when TkSTRING
|
|
|
|
eval @read[-1]
|
2010-12-19 22:22:49 -05:00
|
|
|
when TkDSTRING, TkIDENTIFIER then
|
|
|
|
nil # ignore
|
2008-01-13 22:34:05 -05:00
|
|
|
else
|
|
|
|
warn("Expected symbol or string, got #{tk.inspect}") if $DEBUG_RDOC
|
|
|
|
nil
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Parses statements at the toplevel in +container+
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
def parse_top_level_statements(container)
|
2008-07-17 20:46:16 -04:00
|
|
|
comment = collect_first_comment
|
|
|
|
look_for_directives_in(container, comment)
|
2010-12-19 22:22:49 -05:00
|
|
|
container.comment = comment if container.document_self unless comment.empty?
|
2008-07-17 20:46:16 -04:00
|
|
|
parse_statements container, NORMAL, nil, comment
|
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Determines the visibility in +container+ from +tk+
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_visibility(container, single, tk)
|
|
|
|
singleton = (single == SINGLE)
|
|
|
|
|
|
|
|
vis_type = tk.name
|
|
|
|
|
|
|
|
vis = case vis_type
|
|
|
|
when 'private' then :private
|
|
|
|
when 'protected' then :protected
|
|
|
|
when 'public' then :public
|
|
|
|
when 'private_class_method' then
|
|
|
|
singleton = true
|
|
|
|
:private
|
|
|
|
when 'public_class_method' then
|
|
|
|
singleton = true
|
|
|
|
:public
|
|
|
|
when 'module_function' then
|
|
|
|
singleton = true
|
|
|
|
:public
|
|
|
|
else
|
2010-04-01 03:45:16 -04:00
|
|
|
raise RDoc::Error, "Invalid visibility: #{tk.name}"
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
skip_tkspace_comment false
|
|
|
|
|
|
|
|
case peek_tk
|
|
|
|
# Ryan Davis suggested the extension to ignore modifiers, because he
|
|
|
|
# often writes
|
|
|
|
#
|
|
|
|
# protected unless $TESTING
|
|
|
|
#
|
|
|
|
when TkNL, TkUNLESS_MOD, TkIF_MOD, TkSEMICOLON then
|
|
|
|
container.ongoing_visibility = vis
|
|
|
|
else
|
2011-05-13 20:39:16 -04:00
|
|
|
new_methods = []
|
|
|
|
|
2011-05-15 07:55:52 -04:00
|
|
|
case vis_type
|
2011-05-13 20:39:16 -04:00
|
|
|
when 'module_function' then
|
2008-07-17 20:46:16 -04:00
|
|
|
args = parse_symbol_arg
|
|
|
|
container.set_visibility_for args, :private, false
|
|
|
|
|
|
|
|
container.methods_matching args do |m|
|
|
|
|
s_m = m.dup
|
2010-12-19 22:22:49 -05:00
|
|
|
s_m.record_location @top_level
|
|
|
|
s_m.singleton = true
|
2011-05-13 20:39:16 -04:00
|
|
|
new_methods << s_m
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2011-05-13 20:39:16 -04:00
|
|
|
when 'public_class_method', 'private_class_method' then
|
|
|
|
args = parse_symbol_arg
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2011-05-13 20:39:16 -04:00
|
|
|
container.methods_matching args, true do |m|
|
|
|
|
if m.parent != container then
|
|
|
|
m = m.dup
|
|
|
|
m.record_location @top_level
|
|
|
|
new_methods << m
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2011-05-13 20:39:16 -04:00
|
|
|
|
|
|
|
m.visibility = vis
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
else
|
|
|
|
args = parse_symbol_arg
|
|
|
|
container.set_visibility_for args, vis, singleton
|
|
|
|
end
|
2011-05-13 20:39:16 -04:00
|
|
|
|
|
|
|
new_methods.each do |method|
|
|
|
|
case method
|
|
|
|
when RDoc::AnyMethod then
|
|
|
|
container.add_method method
|
|
|
|
when RDoc::Attr then
|
|
|
|
container.add_attribute method
|
|
|
|
end
|
|
|
|
method.visibility = vis
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Determines the block parameter for +context+
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def parse_yield(context, single, tk, method)
|
2010-04-10 02:36:13 -04:00
|
|
|
return if method.block_params
|
|
|
|
|
|
|
|
get_tkread
|
|
|
|
@scanner.instance_eval { @continue = false }
|
|
|
|
method.block_params = parse_method_or_yield_parameters
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
##
|
|
|
|
# Directives are modifier comments that can appear after class, module, or
|
|
|
|
# method names. For example:
|
|
|
|
#
|
|
|
|
# def fred # :yields: a, b
|
|
|
|
#
|
|
|
|
# or:
|
|
|
|
#
|
|
|
|
# class MyClass # :nodoc:
|
|
|
|
#
|
|
|
|
# We return the directive name and any parameters as a two element array
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
def read_directive allowed
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
2010-04-01 03:45:16 -04:00
|
|
|
|
|
|
|
if TkCOMMENT === tk then
|
2010-12-19 22:22:49 -05:00
|
|
|
return unless tk.text =~ /\s*:?(\w+):\s*(.*)/
|
|
|
|
|
|
|
|
directive = $1.downcase
|
|
|
|
|
|
|
|
return [directive, $2] if allowed.include? directive
|
2008-07-17 20:46:16 -04:00
|
|
|
else
|
2010-04-01 03:45:16 -04:00
|
|
|
unget_tk tk
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Handles the directive for +context+ if the directive is listed in +allow+.
|
|
|
|
# This method is called for directives following a definition.
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
def read_documentation_modifiers(context, allow)
|
|
|
|
directive, value = read_directive allow
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
return unless directive
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
case directive
|
|
|
|
when 'notnew', 'not_new', 'not-new' then
|
|
|
|
context.dont_rename_initialize = true
|
|
|
|
else
|
|
|
|
RDoc::Parser.process_directive context, directive, value
|
|
|
|
end
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Removes private comments from +comment+
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def remove_private_comments(comment)
|
2011-02-01 19:32:30 -05:00
|
|
|
empty = ''
|
|
|
|
empty.force_encoding comment.encoding if Object.const_defined? :Encoding
|
|
|
|
|
|
|
|
comment.gsub!(/^#--.*?^#\+\+\n?/m, empty)
|
|
|
|
comment.sub!(/^#--.*/m, '')
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Scans this ruby file for ruby constructs
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def scan
|
|
|
|
reset
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
catch :eof do
|
2010-12-19 22:22:49 -05:00
|
|
|
begin
|
|
|
|
parse_top_level_statements @top_level
|
|
|
|
rescue StandardError => e
|
|
|
|
bytes = ''
|
|
|
|
|
|
|
|
20.times do @scanner.ungetc end
|
|
|
|
count = 0
|
|
|
|
60.times do |i|
|
|
|
|
count = i
|
|
|
|
byte = @scanner.getc
|
|
|
|
break unless byte
|
|
|
|
bytes << byte
|
|
|
|
end
|
|
|
|
count -= 20
|
|
|
|
count.times do @scanner.ungetc end
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
$stderr.puts <<-EOF
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
#{self.class} failure around line #{@scanner.line_no} of
|
|
|
|
#{@file_name}
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
EOF
|
2008-07-17 20:46:16 -04:00
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
unless bytes.empty? then
|
|
|
|
$stderr.puts
|
|
|
|
$stderr.puts bytes.inspect
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
2010-12-19 22:22:49 -05:00
|
|
|
|
|
|
|
raise e
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
@top_level
|
|
|
|
end
|
|
|
|
|
|
|
|
##
|
|
|
|
# while, until, and for have an optional do
|
|
|
|
|
|
|
|
def skip_optional_do_after_expression
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
|
|
|
case tk
|
2010-04-19 01:08:28 -04:00
|
|
|
when TkLPAREN, TkfLPAREN then
|
2008-07-17 20:46:16 -04:00
|
|
|
end_token = TkRPAREN
|
|
|
|
else
|
|
|
|
end_token = TkNL
|
|
|
|
end
|
|
|
|
|
2010-04-19 01:08:28 -04:00
|
|
|
b_nest = 0
|
2008-07-17 20:46:16 -04:00
|
|
|
nest = 0
|
2010-04-19 01:08:28 -04:00
|
|
|
@scanner.instance_eval { @continue = false }
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
loop do
|
|
|
|
case tk
|
2010-04-19 01:08:28 -04:00
|
|
|
when TkSEMICOLON then
|
|
|
|
break if b_nest.zero?
|
|
|
|
when TkLPAREN, TkfLPAREN then
|
2008-07-17 20:46:16 -04:00
|
|
|
nest += 1
|
2010-04-19 01:08:28 -04:00
|
|
|
when TkBEGIN then
|
|
|
|
b_nest += 1
|
|
|
|
when TkEND then
|
|
|
|
b_nest -= 1
|
2008-07-17 20:46:16 -04:00
|
|
|
when TkDO
|
|
|
|
break if nest.zero?
|
2010-04-19 01:08:28 -04:00
|
|
|
when end_token then
|
2008-07-17 20:46:16 -04:00
|
|
|
if end_token == TkRPAREN
|
|
|
|
nest -= 1
|
|
|
|
break if @scanner.lex_state == EXPR_END and nest.zero?
|
|
|
|
else
|
|
|
|
break unless @scanner.continue
|
|
|
|
end
|
2010-04-01 03:45:16 -04:00
|
|
|
when nil then
|
|
|
|
break
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
tk = get_tk
|
|
|
|
end
|
2010-04-19 01:08:28 -04:00
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
|
|
|
|
get_tk if TkDO === peek_tk
|
|
|
|
end
|
|
|
|
|
|
|
|
##
|
|
|
|
# skip the var [in] part of a 'for' statement
|
|
|
|
|
|
|
|
def skip_for_variable
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace false
|
2008-07-17 20:46:16 -04:00
|
|
|
tk = get_tk
|
|
|
|
unget_tk(tk) unless TkIN === tk
|
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Skips the next method in +container+
|
|
|
|
|
2010-04-01 03:45:16 -04:00
|
|
|
def skip_method container
|
2008-07-17 20:46:16 -04:00
|
|
|
meth = RDoc::AnyMethod.new "", "anon"
|
2010-04-01 03:45:16 -04:00
|
|
|
parse_method_parameters meth
|
|
|
|
parse_statements container, false, meth
|
2008-07-17 20:46:16 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
##
|
|
|
|
# Skip spaces until a comment is found
|
|
|
|
|
|
|
|
def skip_tkspace_comment(skip_nl = true)
|
|
|
|
loop do
|
2010-04-01 03:45:16 -04:00
|
|
|
skip_tkspace skip_nl
|
2008-07-17 20:46:16 -04:00
|
|
|
return unless TkCOMMENT === peek_tk
|
|
|
|
get_tk
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-12-19 22:22:49 -05:00
|
|
|
##
|
|
|
|
# Prints +msg+ to +$stderr+ unless we're being quiet
|
|
|
|
|
2008-07-17 20:46:16 -04:00
|
|
|
def warn(msg)
|
|
|
|
return if @options.quiet
|
|
|
|
msg = make_message msg
|
|
|
|
$stderr.puts msg
|
|
|
|
end
|
|
|
|
|
2003-12-01 02:12:49 -05:00
|
|
|
end
|
2008-01-07 01:56:46 -05:00
|
|
|
|