Class: RipperTags::Visitor

Inherits:
Object
  • Object
show all
Defined in:
lib/ripper-tags/parser.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(sexp, path, data) ⇒ Visitor

Returns a new instance of Visitor.



349
350
351
352
353
354
355
356
357
358
 
# File 'lib/ripper-tags/parser.rb', line 349

def initialize(sexp, path, data)
  @path = path
  @lines = data.split("\n")
  @namespace = []
  @tags = []
  @is_singleton = false
  @current_access = nil

  process(sexp)
end

Instance Attribute Details

#tags ⇒ Object (readonly)

Returns the value of attribute tags.



347
348
349
 
# File 'lib/ripper-tags/parser.rb', line 347

def tags
  @tags
end

Instance Method Details

#emit_tag(kind, line, opts = {}) ⇒ Object 



360
361
362
363
364
365
366
367
368
369
 
# File 'lib/ripper-tags/parser.rb', line 360

def emit_tag(kind, line, opts={})
  @tags << {
    :kind => kind.to_s,
    :line => line,
    :language => 'Ruby',
    :path => @path,
    :pattern => @lines[line-1].chomp,
    :access => @current_access
  }.update(opts).delete_if{ |k,v| v.nil? }
end

#on_alias(name, other, line) ⇒ Object 



464
465
466
467
468
469
470
471
472
 
# File 'lib/ripper-tags/parser.rb', line 464

def on_alias(name, other, line)
  ns = (@namespace.empty?? 'Object' : @namespace.join('::'))

  emit_tag :alias, line,
    :name => name,
    :inherits => other,
    :full_name => "#{ns}#{@is_singleton ? '.' : '#'}#{name}",
    :class => ns
end

#on_assign(name, rhs, line, *junk) ⇒ Object

Ripper trips up on keyword arguments in pre-2.1 Ruby and supplies extra arguments that we just ignore here



439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
 
# File 'lib/ripper-tags/parser.rb', line 439

def on_assign(name, rhs, line, *junk)
  return unless name =~ /^[A-Z]/ && junk.empty?

  if rhs && :call == rhs[0] && rhs[1] && "#{rhs[1][0]}.#{rhs[2]}" =~ /^(Class|Module|Struct)\.new$/
    kind = $1 == 'Module' ? :module : :class
    superclass = $1 == 'Class' ? rhs[3] : nil
    superclass.flatten! if superclass
    return on_module_or_class(kind, [name, line], superclass, rhs[4])
  end

  namespace = @namespace
  if name.include?('::')
    parts = name.split('::')
    name = parts.pop
    namespace = namespace + parts
  end

  process(rhs)

  emit_tag :constant, line,
    :name => name,
    :full_name => (namespace + [name]).join('::'),
    :class => namespace.join('::')
end

#on_call(*args) ⇒ Object Also known as: on_aref_field, on_field, on_fcall, on_args, on_assoc, on_! 



540
541
 
# File 'lib/ripper-tags/parser.rb', line 540

def on_call(*args)
end

#on_class(name, superclass, *body) ⇒ Object 



422
423
424
 
# File 'lib/ripper-tags/parser.rb', line 422

def on_class(name, superclass, *body)
  on_module_or_class(:class, name, superclass, *body)
end

#on_class_eval(name, body) ⇒ Object 



532
533
534
535
536
537
538
 
# File 'lib/ripper-tags/parser.rb', line 532

def on_class_eval(name, body)
  name, _ = *name
  @namespace << name
  process(body)
ensure
  @namespace.pop
end

#on_def(name, line) ⇒ Object 



474
475
476
477
478
479
480
481
482
 
# File 'lib/ripper-tags/parser.rb', line 474

def on_def(name, line)
  kind = @is_singleton ? 'singleton method' : 'method'
  ns = (@namespace.empty?? 'Object' : @namespace.join('::'))

  emit_tag kind, line,
    :name => name,
    :full_name => "#{ns}#{@is_singleton ? '.' : '#'}#{name}",
    :class => ns
end

#on_def_with_access(klass, name, access, line) ⇒ Object 



492
493
494
495
496
497
498
499
500
501
502
 
# File 'lib/ripper-tags/parser.rb', line 492

def on_def_with_access(klass, name, access, line)
  ns = (@namespace.empty? ? 'Object' : @namespace.join('::'))
  singleton = @is_singleton || klass == 'self'
  kind = singleton ? 'singleton method' : 'method'

  emit_tag kind, line,
    :name => name,
    :full_name => "#{ns}#{singleton ? '.' : '#'}#{name}",
    :class => ns,
    :access => access
end

#on_defs(klass, name, line) ⇒ Object 



484
485
486
487
488
489
490
 
# File 'lib/ripper-tags/parser.rb', line 484

def on_defs(klass, name, line)
  ns = (@namespace + [klass != 'self' ? klass : nil]).compact
  emit_tag 'singleton method', line,
    :name => name,
    :full_name => ns.join('::') + ".#{name}",
    :class => ns.join('::')
end

#on_module(name, *body) ⇒ Object 



418
419
420
 
# File 'lib/ripper-tags/parser.rb', line 418

def on_module(name, *body)
  on_module_or_class(:module, name, nil, *body)
end

#on_module_function ⇒ Object 



432
433
434
435
 
# File 'lib/ripper-tags/parser.rb', line 432

def on_module_function()
  @is_singleton = true
  @current_access = 'public'
end

#on_module_or_class(kind, name, superclass, *body) ⇒ Object 



389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
 
# File 'lib/ripper-tags/parser.rb', line 389

def on_module_or_class(kind, name, superclass, *body)
  name, line = *name
  @namespace << name

  prev_access = @current_access
  @current_access = nil

  if superclass
    superclass_name = superclass[0] == :call ?
      superclass[1] :
      superclass[0]
    superclass_name = nil unless superclass_name =~ /^[A-Z]/
  end
  full_name = @namespace.join('::')
  parts = full_name.split('::')
  class_name = parts.pop

  emit_tag kind, line,
    :full_name => full_name,
    :name => class_name,
    :class => parts.any? && parts.join('::') || nil,
    :inherits => superclass_name

  process(body)
ensure
  @current_access = prev_access
  @namespace.pop
end

#on_private ⇒ Object 



426
 
# File 'lib/ripper-tags/parser.rb', line 426

def on_private()              @current_access = 'private'   end

#on_private_class_method ⇒ Object 



429
 
# File 'lib/ripper-tags/parser.rb', line 429

def on_private_class_method() @current_access = 'private'   end

#on_protected ⇒ Object 



427
 
# File 'lib/ripper-tags/parser.rb', line 427

def on_protected()            @current_access = 'protected' end

#on_public ⇒ Object 



428
 
# File 'lib/ripper-tags/parser.rb', line 428

def on_public()               @current_access = 'public'    end

#on_public_class_method ⇒ Object 



430
 
# File 'lib/ripper-tags/parser.rb', line 430

def on_public_class_method()  @current_access = 'public'    end

#on_rails_def(kind, name, line) ⇒ Object 



512
513
514
515
516
517
518
519
520
 
# File 'lib/ripper-tags/parser.rb', line 512

def on_rails_def(kind, name, line)
  ns = (@namespace.empty?? 'Object' : @namespace.join('::'))

  emit_tag kind, line,
    :language => 'Rails',
    :name => name,
    :full_name => "#{ns}.#{name}",
    :class => ns
end

#on_redefine_access(klass, name, access, line) ⇒ Object 



504
505
506
507
508
509
510
 
# File 'lib/ripper-tags/parser.rb', line 504

def on_redefine_access(klass, name, access, line)
  ns = (@namespace.empty? ? 'Object' : @namespace.join('::'))
  singleton = @is_singleton || klass == 'self'
  full_name = "#{ns}#{singleton ? '.' : '#'}#{name}"
  tag = @tags.select { |t| t[:full_name] == full_name }.last
  tag[:access] = access if tag
end

#on_sclass(name, body) ⇒ Object 



522
523
524
525
526
527
528
529
530
 
# File 'lib/ripper-tags/parser.rb', line 522

def on_sclass(name, body)
  name, _ = *name
  @namespace << name unless name == 'self'
  prev_is_singleton, @is_singleton = @is_singleton, true
  process(body)
ensure
  @namespace.pop     unless name == 'self'
  @is_singleton = prev_is_singleton
end

#process(sexp) ⇒ Object 



371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/ripper-tags/parser.rb', line 371

def process(sexp)
  return unless sexp
  return if Symbol === sexp

  case sexp[0]
  when Array
    sexp.each{ |child| process(child) }
  when Symbol
    name, *args = sexp
    name = name.to_s
    if name.index("@") != 0 && name.index("-@") != 0
      __send__("on_#{name}", *args)
    end
  when String, nil
    # nothing
  end
end