test/rdoc/test_rdoc_parser_ruby.rb

   1 require 'stringio'
   2 require 'tempfile'
   3 require 'test/unit'
   4
   5 require 'rdoc/options'
   6 require 'rdoc/parser/ruby'
   7 require 'rdoc/stats'
   8
   9 class TestRdocParserRuby < Test::Unit::TestCase
  10
  11   def setup
  12     @tempfile = Tempfile.new self.class.name
  13     @filename = @tempfile.path
  14
  15     util_toplevel
  16     @options = RDoc::Options.new Hash.new
  17     @options.quiet = true
  18     @stats = RDoc::Stats.new
  19
  20     @progress = StringIO.new
  21   end
  22
  23   def teardown
  24     @tempfile.unlink
  25   end
  26
  27   def test_look_for_directives_in_commented
  28     util_parser ""
  29
  30     comment = "# how to make a section:\n# # :section: new section\n"
  31
  32     @parser.look_for_directives_in @top_level, comment
  33
  34     section = @top_level.current_section
  35     assert_equal nil, section.title
  36     assert_equal nil, section.comment
  37
  38     assert_equal "# how to make a section:\n# # :section: new section\n",
  39                  comment
  40   end
  41
  42   def test_look_for_directives_in_enddoc
  43     util_parser ""
  44
  45     assert_throws :enddoc do
  46       @parser.look_for_directives_in @top_level, "# :enddoc:\n"
  47     end
  48   end
  49
  50   def test_look_for_directives_in_main
  51     util_parser ""
  52
  53     @parser.look_for_directives_in @top_level, "# :main: new main page\n"
  54
  55     assert_equal 'new main page', @options.main_page
  56   end
  57
  58   def test_look_for_directives_in_method
  59     util_parser ""
  60
  61     comment = "# :method: my_method\n"
  62
  63     @parser.look_for_directives_in @top_level, comment
  64
  65     assert_equal "# :method: my_method\n", comment
  66
  67     comment = "# :singleton-method: my_method\n"
  68
  69     @parser.look_for_directives_in @top_level, comment
  70
  71     assert_equal "# :singleton-method: my_method\n", comment
  72   end
  73
  74   def test_look_for_directives_in_startdoc
  75     util_parser ""
  76
  77     @top_level.stop_doc
  78     assert !@top_level.document_self
  79     assert !@top_level.document_children
  80     assert !@top_level.force_documentation
  81
  82     @parser.look_for_directives_in @top_level, "# :startdoc:\n"
  83
  84     assert @top_level.document_self
  85     assert @top_level.document_children
  86     assert @top_level.force_documentation
  87   end
  88
  89   def test_look_for_directives_in_stopdoc
  90     util_parser ""
  91
  92     assert @top_level.document_self
  93     assert @top_level.document_children
  94
  95     @parser.look_for_directives_in @top_level, "# :stopdoc:\n"
  96
  97     assert !@top_level.document_self
  98     assert !@top_level.document_children
  99   end
 100
 101   def test_look_for_directives_in_section
 102     util_parser ""
 103
 104     comment = "# :section: new section\n# woo stuff\n"
 105
 106     @parser.look_for_directives_in @top_level, comment
 107
 108     section = @top_level.current_section
 109     assert_equal 'new section', section.title
 110     assert_equal "# woo stuff\n", section.comment
 111
 112     assert_equal '', comment
 113   end
 114
 115   def test_look_for_directives_in_title
 116     util_parser ""
 117
 118     @parser.look_for_directives_in @top_level, "# :title: new title\n"
 119
 120     assert_equal 'new title', @options.title
 121   end
 122
 123   def test_look_for_directives_in_unhandled
 124     util_parser ""
 125
 126     comment = "# :unhandled: \n# :title: hi\n"
 127
 128     @parser.look_for_directives_in @top_level, comment
 129
 130     assert_equal "# :unhandled: \n", comment
 131
 132     assert_equal 'hi', @options.title
 133   end
 134
 135   def test_parse_meta_method
 136     klass = RDoc::NormalClass.new 'Foo'
 137     klass.parent = @top_level
 138
 139     comment = "##\n# my method\n"
 140
 141     util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
 142
 143     tk = @parser.get_tk
 144
 145     @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 146
 147     foo = klass.method_list.first
 148     assert_equal 'foo', foo.name
 149     assert_equal comment, foo.comment
 150
 151     assert_equal [],      foo.aliases
 152     assert_equal nil,     foo.block_params
 153     assert_equal nil,     foo.call_seq
 154     assert_equal true,    foo.document_children
 155     assert_equal true,    foo.document_self
 156     assert_equal false,   foo.done_documenting
 157     assert_equal false,   foo.dont_rename_initialize
 158     assert_equal false,   foo.force_documentation
 159     assert_equal nil,     foo.is_alias_for
 160     assert_equal '',      foo.params
 161     assert_equal klass,   foo.parent
 162     assert_equal false,   foo.singleton
 163     assert_equal 'add_my_method :foo', foo.text
 164     assert_equal nil,     foo.viewer
 165     assert_equal :public, foo.visibility
 166     assert_equal klass.current_section, foo.section
 167
 168     stream = [
 169       tk(:COMMENT, 1, 1, nil, "# File #{@top_level.file_absolute_name}, line 1"),
 170       RDoc::Parser::Ruby::NEWLINE_TOKEN,
 171       tk(:SPACE,      1, 1,  nil, ''),
 172       tk(:IDENTIFIER, 1, 0,  'add_my_method', 'add_my_method'),
 173       tk(:SPACE,      1, 13, nil, ' '),
 174       tk(:SYMBOL,     1, 14, nil, ':foo'),
 175       tk(:COMMA,      1, 18, nil, ','),
 176       tk(:SPACE,      1, 19, nil, ' '),
 177       tk(:SYMBOL,     1, 20, nil, ':bar'),
 178       tk(:NL,         1, 24, nil, "\n"),
 179     ]
 180
 181     assert_equal stream, foo.token_stream
 182   end
 183
 184   def test_parse_meta_method_name
 185     klass = RDoc::NormalClass.new 'Foo'
 186     klass.parent = @top_level
 187
 188     comment = "##\n# :method: woo_hoo!\n# my method\n"
 189
 190     util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
 191
 192     tk = @parser.get_tk
 193
 194     @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 195
 196     foo = klass.method_list.first
 197     assert_equal 'woo_hoo!', foo.name
 198     assert_equal "##\n# my method\n", foo.comment
 199   end
 200
 201   def test_parse_meta_method_singleton
 202     klass = RDoc::NormalClass.new 'Foo'
 203     klass.parent = @top_level
 204
 205     comment = "##\n# :singleton-method:\n# my method\n"
 206
 207     util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
 208
 209     tk = @parser.get_tk
 210
 211     @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 212
 213     foo = klass.method_list.first
 214     assert_equal 'foo', foo.name
 215     assert_equal true, foo.singleton, 'singleton method'
 216     assert_equal "##\n# my method\n", foo.comment
 217   end
 218
 219   def test_parse_meta_method_singleton_name
 220     klass = RDoc::NormalClass.new 'Foo'
 221     klass.parent = @top_level
 222
 223     comment = "##\n# :singleton-method: woo_hoo!\n# my method\n"
 224
 225     util_parser "add_my_method :foo, :bar\nadd_my_method :baz"
 226
 227     tk = @parser.get_tk
 228
 229     @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 230
 231     foo = klass.method_list.first
 232     assert_equal 'woo_hoo!', foo.name
 233     assert_equal true, foo.singleton, 'singleton method'
 234     assert_equal "##\n# my method\n", foo.comment
 235   end
 236
 237   def test_parse_meta_method_string_name
 238     klass = RDoc::NormalClass.new 'Foo'
 239     comment = "##\n# my method\n"
 240
 241     util_parser "add_my_method 'foo'"
 242
 243     tk = @parser.get_tk
 244
 245     @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 246
 247     foo = klass.method_list.first
 248     assert_equal 'foo', foo.name
 249     assert_equal comment, foo.comment
 250   end
 251
 252   def test_parse_method
 253     klass = RDoc::NormalClass.new 'Foo'
 254     klass.parent = @top_level
 255
 256     comment = "##\n# my method\n"
 257
 258     util_parser "def foo() :bar end"
 259
 260     tk = @parser.get_tk
 261
 262     @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 263
 264     foo = klass.method_list.first
 265     assert_equal 'foo',     foo.name
 266     assert_equal comment,   foo.comment
 267
 268     assert_equal [],        foo.aliases
 269     assert_equal nil,       foo.block_params
 270     assert_equal nil,       foo.call_seq
 271     assert_equal nil,       foo.is_alias_for
 272     assert_equal nil,       foo.viewer
 273     assert_equal true,      foo.document_children
 274     assert_equal true,      foo.document_self
 275     assert_equal '()',      foo.params
 276     assert_equal false,     foo.done_documenting
 277     assert_equal false,     foo.dont_rename_initialize
 278     assert_equal false,     foo.force_documentation
 279     assert_equal klass,     foo.parent
 280     assert_equal false,     foo.singleton
 281     assert_equal :public,   foo.visibility
 282     assert_equal 'def foo', foo.text
 283     assert_equal klass.current_section, foo.section
 284
 285     stream = [
 286       tk(:COMMENT, 1, 1, nil, "# File #{@top_level.file_absolute_name}, line 1"),
 287       RDoc::Parser::Ruby::NEWLINE_TOKEN,
 288       tk(:SPACE,      1, 1,  nil,   ''),
 289       tk(:DEF,        1, 0,  'def', 'def'),
 290       tk(:SPACE,      1, 3,  nil,   ' '),
 291       tk(:IDENTIFIER, 1, 4,  'foo', 'foo'),
 292       tk(:LPAREN,     1, 7,  nil,   '('),
 293       tk(:RPAREN,     1, 8,  nil,   ')'),
 294       tk(:SPACE,      1, 9,  nil,   ' '),
 295       tk(:COLON,      1, 10, nil,   ':'),
 296       tk(:IDENTIFIER, 1, 11, 'bar', 'bar'),
 297       tk(:SPACE,      1, 14, nil,   ' '),
 298       tk(:END,        1, 15, 'end', 'end'),
 299     ]
 300
 301     assert_equal stream, foo.token_stream
 302   end
 303
 304   def test_parse_statements_comment
 305     content = <<-EOF
 306 class Foo
 307   ##
 308   # :method: my_method
 309   # my method comment
 310
 311 end
 312     EOF
 313     klass = RDoc::NormalClass.new 'Foo'
 314     klass.parent = @top_level
 315
 316     comment = "##\n# :method: foo\n# my method\n"
 317
 318     util_parser "\n"
 319
 320     tk = @parser.get_tk
 321
 322     @parser.parse_comment klass, tk, comment
 323
 324     foo = klass.method_list.first
 325     assert_equal 'foo',     foo.name
 326     assert_equal comment,   foo.comment
 327
 328     assert_equal [],        foo.aliases
 329     assert_equal nil,       foo.block_params
 330     assert_equal nil,       foo.call_seq
 331     assert_equal nil,       foo.is_alias_for
 332     assert_equal nil,       foo.viewer
 333     assert_equal true,      foo.document_children
 334     assert_equal true,      foo.document_self
 335     assert_equal '',        foo.params
 336     assert_equal false,     foo.done_documenting
 337     assert_equal false,     foo.dont_rename_initialize
 338     assert_equal false,     foo.force_documentation
 339     assert_equal klass,     foo.parent
 340     assert_equal false,     foo.singleton
 341     assert_equal :public,   foo.visibility
 342     assert_equal "\n",      foo.text
 343     assert_equal klass.current_section, foo.section
 344
 345     stream = [
 346       tk(:COMMENT, 1, 1, nil, "# File #{@top_level.file_absolute_name}, line 1"),
 347       RDoc::Parser::Ruby::NEWLINE_TOKEN,
 348       tk(:SPACE,      1, 1,  nil,   ''),
 349     ]
 350
 351     assert_equal stream, foo.token_stream
 352   end
 353
 354   def test_parse_statements_identifier_meta_method
 355     content = <<-EOF
 356 class Foo
 357   ##
 358   # this is my method
 359   add_my_method :foo
 360 end
 361     EOF
 362
 363     util_parser content
 364
 365     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 366
 367     foo = @top_level.classes.first.method_list.first
 368     assert_equal 'foo', foo.name
 369   end
 370
 371   def test_parse_statements_identifier_alias_method
 372     content = "class Foo def foo() end; alias_method :foo2, :foo end"
 373
 374     util_parser content
 375
 376     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 377
 378     foo2 = @top_level.classes.first.method_list.last
 379     assert_equal 'foo2', foo2.name
 380     assert_equal 'foo', foo2.is_alias_for.name
 381   end
 382
 383   def test_parse_statements_identifier_attr
 384     content = "class Foo; attr :foo; end"
 385
 386     util_parser content
 387
 388     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 389
 390     foo = @top_level.classes.first.attributes.first
 391     assert_equal 'foo', foo.name
 392     assert_equal 'R', foo.rw
 393   end
 394
 395   def test_parse_statements_identifier_attr_accessor
 396     content = "class Foo; attr_accessor :foo; end"
 397
 398     util_parser content
 399
 400     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 401
 402     foo = @top_level.classes.first.attributes.first
 403     assert_equal 'foo', foo.name
 404     assert_equal 'RW', foo.rw
 405   end
 406
 407   def test_parse_statements_identifier_extra_accessors
 408     @options.extra_accessors = /^my_accessor$/
 409
 410     content = "class Foo; my_accessor :foo; end"
 411
 412     util_parser content
 413
 414     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 415
 416     foo = @top_level.classes.first.attributes.first
 417     assert_equal 'foo', foo.name
 418     assert_equal '?', foo.rw
 419   end
 420
 421   def test_parse_statements_identifier_include
 422     content = "class Foo; include Bar; end"
 423
 424     util_parser content
 425
 426     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 427
 428     foo = @top_level.classes.first
 429     assert_equal 'Foo', foo.name
 430     assert_equal 1, foo.includes.length
 431   end
 432
 433   def test_parse_statements_identifier_module_function
 434     content = "module Foo def foo() end; module_function :foo; end"
 435
 436     util_parser content
 437
 438     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 439
 440     foo, s_foo = @top_level.modules.first.method_list
 441     assert_equal 'foo', foo.name, 'instance method name'
 442     assert_equal :private, foo.visibility, 'instance method visibility'
 443     assert_equal false, foo.singleton, 'instance method singleton'
 444
 445     assert_equal 'foo', s_foo.name, 'module function name'
 446     assert_equal :public, s_foo.visibility, 'module function visibility'
 447     assert_equal true, s_foo.singleton, 'module function singleton'
 448   end
 449
 450   def test_parse_statements_identifier_private
 451     content = "class Foo private; def foo() end end"
 452
 453     util_parser content
 454
 455     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 456
 457     foo = @top_level.classes.first.method_list.first
 458     assert_equal 'foo', foo.name
 459     assert_equal :private, foo.visibility
 460   end
 461
 462   def test_parse_statements_identifier_require
 463     content = "require 'bar'"
 464
 465     util_parser content
 466
 467     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 468
 469     assert_equal 1, @top_level.requires.length
 470   end
 471
 472   def tk(klass, line, char, name, text)
 473     klass = RDoc::RubyToken.const_get "Tk#{klass.to_s.upcase}"
 474
 475     token = if klass.instance_method(:initialize).arity == 2 then
 476               raise ArgumentError, "name not used for #{klass}" unless name.nil?
 477               klass.new line, char
 478             else
 479               klass.new line, char, name
 480             end
 481
 482     token.set_text text
 483
 484     token
 485   end
 486
 487   def util_parser(content)
 488     @parser = RDoc::Parser::Ruby.new @top_level, @filename, content, @options,
 489                                      @stats
 490     @parser.progress = @progress
 491     @parser
 492   end
 493
 494   def util_toplevel
 495     RDoc::TopLevel.reset
 496     @top_level = RDoc::TopLevel.new @filename
 497   end
 498
 499 end
 500