Class: Generators::ContextUser

Inherits:
Object
  • Object
show all
Includes:
MarkUp
Defined in:
lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb,
lib/generators/templates/application/merb_stack/doc/rdoc/generators/merb_generator.rb

Overview

A Context is built by the parser to represent a container: contexts hold classes, modules, methods, require lists and include lists. ClassModule and TopLevel are the context objects we process here

Direct Known Subclasses

HtmlClass, HtmlFile

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from MarkUp

#cvs_url, #markup, #style_url

Constructor Details

#initialize(context, options) ⇒ ContextUser

Returns a new instance of ContextUser.



270
271
272
273
274
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 270

def initialize(context, options)
    @context = context
    @options = options

end

Instance Attribute Details

#context ⇒ Object (readonly)

Returns the value of attribute context.



268
269
270
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 268

def context
  @context
end

Instance Method Details

#add_table_of_sections ⇒ Object

create table of contents if we contain sections



522
523
524
525
526
527
528
529
530
531
532
533
534
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 522

def add_table_of_sections
    toc = []
    @context.sections.each do |section|
        if section.title
            toc << {
                'secname' => section.title,
                'href'    => section.sequence
            }
        end
    end

    @values['toc'] = toc unless toc.empty?
end

#build_alias_summary_list(section) ⇒ Object

Build a list of aliases for which we couldn’t find a corresponding method



312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 312

def build_alias_summary_list(section)
    values = []
    @context.aliases.each do |al|
        next unless al.section == section
        res = {
            'old_name' => al.old_name,
            'new_name' => al.new_name,
        }
        if al.comment && !al.comment.empty?
            res['desc'] = markup(al.comment, true)
        end
        values << res
    end
    values
end

#build_class_list(level, from, section, infile = nil) ⇒ Object

Build the structured list of classes and modules contained in this context.



466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 466

def build_class_list(level, from, section, infile=nil)
    res = ""
    prefix = "&nbsp;&nbsp;::" * level;

    from.modules.sort.each do |mod|
        next unless mod.section == section
        next if infile && !mod.defined_in?(infile)
        if mod.document_self
            res << 
            prefix <<
            "Module " <<
            href(mod.viewer.path, "link", mod.full_name) <<
            "<br />\n" <<
            build_class_list(level + 1, mod, section, infile)
        end
    end

    from.classes.sort.each do |cls|
        next unless cls.section == section
        next if infile && !cls.defined_in?(infile)
        if cls.document_self
            res      <<
            prefix << 
            "Class " <<
             href(cls.viewer.path, "link", cls.full_name) <<
            "<br />\n" <<
            build_class_list(level + 1, cls, section, infile)
        end
    end

    res
end

#build_constants_summary_list(section) ⇒ Object

Build a list of constants



329
330
331
332
333
334
335
336
337
338
339
340
341
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 329

def build_constants_summary_list(section)
    values = []
    @context.constants.each do |co|
        next unless co.section == section
        res = {
            'name'  => co.name,
            'value' => CGI.escapeHTML(co.value)
        }
        res['desc'] = markup(co.comment, true) if co.comment && !co.comment.empty?
        values << res
    end
    values
end

#build_include_list(context) ⇒ Object 



347
348
349
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 347

def build_include_list(context)
    potentially_referenced_list(context.includes)
end

#build_method_detail_list(section) ⇒ Object

Build an array of arrays of method details. The outer array has up to six entries, public, private, and protected for both class methods, the other for instance methods. The inner arrays contain a hash for each method



398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 398

def build_method_detail_list(section)
    outer = []

    methods = @methods.sort
    for singleton in [true, false]
        for vis in [ :public, :protected, :private ] 
            res = []
            methods.each do |m|
                if m.section == section and
                    m.document_self and 
                    m.visibility == vis and 
                    m.singleton == singleton
                    row = {}
                    if m.call_seq
                        row["callseq"] = m.call_seq.gsub(/->/, '&rarr;')
                    else
                        row["name"]        = CGI.escapeHTML(m.name)
                        row["params"]      = m.params
                    end
                    desc = m.description.strip
                    row["m_desc"]      = desc unless desc.empty?
                    row["aref"]        = m.aref
                    row["href"]        = m.path
                    row["m_seq"]       = m.seq
                    row["visibility"]  = m.visibility.to_s

                    alias_names = []
                    m.aliases.each do |other|
                        if other.viewer   # won't be if the alias is private
                            alias_names << {
                                'name' => other.name,
                                'href' => other.viewer.path,
                                'aref'  => other.viewer.aref
                            } 
                        end
                    end
                    unless alias_names.empty?
                        row["aka"] = alias_names
                    end

                    #if @options.inline_source
                    code = m.source_code
                    row["sourcecode"] = code if code
                    #else
                    # code = m.src_url
                    #if code
                    #  row["codeurl"] = code
                    # row["imgurl"]  = m.img_url
                    #end
                    #end
                    res << row
                end
            end
            if res.size > 0 
                outer << {
                    "type"    => vis.to_s.capitalize,
                    "category"    => singleton ? "Class" : "Instance",
                    "methods" => res
                }
            end
        end
    end
    outer
end

#build_method_summary_list(path_prefix = "") ⇒ Object

Build a summary list of all the methods in this context



295
296
297
298
299
300
301
302
303
304
305
306
307
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 295

def build_method_summary_list(path_prefix="")
    collect_methods unless @methods
    meths = @methods.sort
    res = []
    meths.each do |meth|
        res << {
            "name" => CGI.escapeHTML(meth.name),
            "aref" => meth.aref,
            "href" => meth.path
        }
    end
    res
end

#build_requires_list(context) ⇒ Object 



343
344
345
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 343

def build_requires_list(context)
    potentially_referenced_list(context.requires) {|fn| [fn + ".rb"] }
end

#collect_methods ⇒ Object

Create a list of HtmlMethod objects for each method in the corresponding context object. If the @options.show_all variable is set (corresponding to the --all option, we include all methods, otherwise just the public ones.



286
287
288
289
290
291
292
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 286

def collect_methods
    list = @context.method_list
    unless @options.show_all
        list = list.find_all {|m| m.visibility == :public || m.visibility == :protected || m.force_documentation }
    end
    @methods = list.collect {|m| HtmlMethod.new(m, self, @options) }
end

#diagram_reference(diagram) ⇒ Object 



503
504
505
506
507
508
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 503

def diagram_reference(diagram)
    res = diagram.gsub(/((?:src|href)=")(.*?)"/) {
        $1 + $2 + '"'
    }
    res
end

#document_self ⇒ Object 



499
500
501
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 499

def document_self
    @context.document_self
end

#find_symbol(symbol, method = nil) ⇒ Object

Find a symbol in ourselves or our parent



512
513
514
515
516
517
518
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 512

def find_symbol(symbol, method=nil)
    res = @context.find_symbol(symbol, method)
    if res
        res = res.viewer
    end
    res
end

#href(link, cls, name) ⇒ Object

convenience method to build a hyperlink # Where’s the DRY in this?? Put this in the template where it belongs



277
278
279
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 277

def href(link, cls, name)
  %{"<a href=\"#\" onclick=\"jsHref('#{link}');\" class=\"#{cls}\">#{name}</a>"}
end

#potentially_referenced_list(array) ⇒ Object

Build a list from an array of Htmlxxx items. Look up each in the AllReferences hash: if we find a corresponding entry, we generate a hyperlink to it, otherwise just output the name. However, some names potentially need massaging. For example, you may require a Ruby file without the .rb extension, but the file names we know about may have it. To deal with this, we pass in a block which performs the massaging, returning an array of alternative names to match



360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
 
# File 'lib/generators/templates/application/merb_core/doc/rdoc/generators/merb_generator.rb', line 360

def potentially_referenced_list(array)
    res = []
    array.each do |i|
        ref = AllReferences[i.name] 
        #         if !ref
        #           container = @context.parent
        #           while !ref && container
        #             name = container.name + "::" + i.name
        #             ref = AllReferences[name] 
        #             container = container.parent
        #           end
        #         end

        ref = @context.find_symbol(i.name)
        ref = ref.viewer if ref

        if !ref && block_given?
            possibles = yield(i.name)
            while !ref and !possibles.empty?
                ref = AllReferences[possibles.shift]
            end
        end
        h_name = CGI.escapeHTML(i.name)
        if ref and ref.document_self
            path = ref.path
            res << { "name" => h_name, "href" => path }
        else
            res << { "name" => h_name, "href" => "" }
        end
    end
    res
end