Class: Sexp

Inherits:
Object
  • Object
show all
Defined in:
lib/code_analyzer/sexp.rb

Instance Method Summary collapse

Instance Method Details

#all ⇒ Array

Get all arguments.

s(:args_add_block,
  s(:args_add,
    s(:args_add, s(:args_new), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "hello", s(1, 6))))),
    s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "world", s(1, 15))))
  ), false
)
    => [
         s(:args_add, s(:args_new), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "hello", s(1, 6))))),
         s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "world", s(1, 15))))
       ]

Returns:

  • (Array) —

    all arguments



299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
 
# File 'lib/code_analyzer/sexp.rb', line 299

def all
  nodes = []
  case sexp_type
  when :args_add_block, :array
    if :args_new == self[1].sexp_type
      nodes << self[2]
    else
      node = self[1]
      while true
        if [:args_add, :args_add_star].include? node.sexp_type
          nodes.unshift node[2]
          node = node[1]
        elsif :args_new == node.sexp_type
          break
        end
      end
    end
  when :args_add
    nodes.unshift self[2]
  end
  nodes
end

#all_conditions ⇒ Array

Get all condition nodes.

s(:binary,
  s(:binary,
    s(:var_ref, s(:@ident, "user", s(1, 0))),
    :==,
    s(:var_ref, s(:@ident, "current_user", s(1, 8)))
  ),
  :"&&",
  s(:call,
    s(:var_ref, s(:@ident, "user", s(1, 24))),
    :".",
    s(:@ident, "valid?", s(1, 29))
  )
)
    => [
         s(:binary,
           s(:var_ref, s(:@ident, "user", s(1, 0))),
           :==,
           s(:var_ref, s(:@ident, "current_user", s(1, 8)))
         ),
         s(:call,
           s(:var_ref, s(:@ident, "user", s(1, 24))),
             :".",
             s(:@ident, "valid?", s(1, 29))
         )
       ]

Returns:

  • (Array) —

    all condition nodes



367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
 
# File 'lib/code_analyzer/sexp.rb', line 367

def all_conditions
  nodes = []
  if :binary == sexp_type && %w(&& || and or).include?(self[2].to_s)
    if :binary == self[1].sexp_type && %w(&& || and or).include?(self[1][2].to_s)
      nodes += self[1].all_conditions
    else
      nodes << self[1]
    end
    if :binary == self[3].sexp_type && %w(&& || and or).include?(self[3][2].to_s)
      nodes += self[3].all_conditions
    else
      nodes << self[3]
    end
  else
    self
  end
end

#argument ⇒ Sexp

Get only argument for binary.

s(:binary,
  s(:var_ref, s(:@ident, "user", s(1, 0))),
  :==,
  s(:var_ref, s(:@ident, "current_user", s(1, 8)))
)
    => s(:var_ref, s(:@ident, "current_user", s(1, 8)))

Returns:

  • (Sexp) —

    argument node



279
280
281
282
283
 
# File 'lib/code_analyzer/sexp.rb', line 279

def argument
  if :binary == sexp_type
    self[3]
  end
end

#arguments ⇒ Sexp

Get arguments node.

s(:command,
  s(:@ident, "resources", s(1, 0)),
  s(:args_add_block,
    s(:args_add, s(:args_new),
      s(:symbol_literal, s(:symbol, s(:@ident, "posts", s(1, 11))))
    ), false
  )
)
    => s(:args_add_block,
         s(:args_add, s(:args_new),
           s(:symbol_literal, s(:symbol, s(:@ident, "posts", s(1, 11))))
         ), false
       )

Returns:

  • (Sexp) —

    arguments node



252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/code_analyzer/sexp.rb', line 252

def arguments
  case sexp_type
  when :command
    self[2]
  when :command_call
    self[4]
  when :method_add_arg
    self[2].arguments
  when :method_add_block
    self[1].arguments
  when :arg_paren
    self[1]
  when :array
    self
  end
end

#array_size ⇒ Integer

Get the array size.

s(:array,
  s(:args_add,
    s(:args_add, s(:args_new), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "first_name", s(1, 2))))),
    s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "last_name", s(1, 16))))
  )
)
    => 2

Returns:

  • (Integer) —

    array size



703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
 
# File 'lib/code_analyzer/sexp.rb', line 703

def array_size
  if :array == sexp_type
    first_node = self[1]
    array_size = 0
    if first_node
      while true
        array_size += 1
        first_node = s(:args_new) == first_node[1] ? first_node[2] : first_node[1]
        if :args_add != first_node.sexp_type
          if :array == first_node.sexp_type
            array_size += first_node.array_size
          end
          break
        end
      end
    end
    array_size
  end
end

#array_values ⇒ Array

Get the array values.

s(:array,
  s(:args_add,
    s(:args_add, s(:args_new), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "first_name", s(1, 2))))),
    s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "last_name", s(1, 16))))
  )
)
    => [
         s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "first_name", s(1, 2)))),
         s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "last_name", s(1, 16))))
       ]

Returns:

  • (Array) —

    array values



737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
 
# File 'lib/code_analyzer/sexp.rb', line 737

def array_values
  case sexp_type
  when :array
    if nil == self[1]
      []
    elsif [:words_add, :qwords_add, :qsymbols_add].include? self[1].sexp_type
      self[1].array_values
    else
      arguments.all
    end
  when :words_add, :qwords_add, :qsymbols_add
    values = []
    node = self
    while true
      if [:words_add, :qwords_add, :qsymbols_add].include? node.sexp_type
        values.unshift node[2]
        node = node[1]
      elsif [:words_new, :qwords_new, :qsymbols_new].include? node.sexp_type
        break
      end
    end
    values
  else
    []
  end
end

#base_class ⇒ Sexp

Get the base class of the class node.

s(:class,
  s(:const_ref, s(:@const, "User", s(1, 6))),
  s(:const_path_ref, s(:var_ref, s(:@const, "ActiveRecord", s(1, 13))), s(:@const, "Base", s(1, 27))),
  s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
)
    => s(:const_path_ref, s(:var_ref, s(:@const, "ActiveRecord", s(1, 13))), s(:@const, "Base", s(1, 27))),

Returns:

  • (Sexp) —

    base class of class node



172
173
174
175
176
 
# File 'lib/code_analyzer/sexp.rb', line 172

def base_class
  if :class == sexp_type
    self[2]
  end
end

#blank? ⇒ Boolean

false

Returns:

  • (Boolean) 


855
856
857
 
# File 'lib/code_analyzer/sexp.rb', line 855

def blank?
  false
end

#block_node ⇒ Sexp

Get block node.

s(:method_add_block,
  s(:command,
    s(:@ident, "resources", s(1, 0)),
    s(:args_add_block, s(:args_add, s(:args_new), s(:symbol_literal, s(:symbol, s(:@ident, "posts", s(1, 11))))), false)
  ),
  s(:do_block, nil,
    s(:stmts_add, s(:stmts_add, s(:stmts_new), s(:void_stmt)),
      s(:command,
      s(:@ident, "resources", s(1, 21)),
      s(:args_add_block, s(:args_add, s(:args_new), s(:symbol_literal, s(:symbol, s(:@ident, "comments", s(1, 32))))), false))
    )
  )
)
    => s(:do_block, nil,
         s(:stmts_add, s(:stmts_add, s(:stmts_new), s(:void_stmt)),
           s(:command,
           s(:@ident, "resources", s(1, 21)),
           s(:args_add_block, s(:args_add, s(:args_new), s(:symbol_literal, s(:symbol, s(:@ident, "comments", s(1, 32))))), false))
         )
       )

Returns:

  • (Sexp) —

    body node



468
469
470
471
472
473
 
# File 'lib/code_analyzer/sexp.rb', line 468

def block_node
  case sexp_type
  when :method_add_block
    self[2]
  end
end

#body ⇒ Sexp

Get body node.

s(:class,
  s(:const_ref, s(:@const, "User", s(1, 6))),
  nil,
  s(:bodystmt,
    s(:stmts_add, s(:stmts_new),
      s(:def,
        s(:@ident, "login", s(1, 16)),
        s(:params, nil, nil, nil, nil, nil),
        s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
      )
    ), nil, nil, nil
  )
)
    => s(:bodystmt,
         s(:stmts_add, s(:stmts_new),
           s(:def,
             s(:@ident, "login", s(1, 16)),
             s(:params, nil, nil, nil, nil, nil),
             s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
           )
         ), nil, nil, nil
       )

Returns:

  • (Sexp) —

    body node



431
432
433
434
435
436
437
438
439
440
441
442
 
# File 'lib/code_analyzer/sexp.rb', line 431

def body
  case sexp_type
  when :else
    self[1]
  when :module, :if, :elsif, :unless, :if_mod, :unless_mod, :ifop
    self[2]
  when :class, :def
    self[3]
  when :defs
    self[5]
  end
end

#check(visitor) ⇒ Object

check current node.

Parameters:



8
9
10
 
# File 'lib/code_analyzer/sexp.rb', line 8

def check(visitor)
  visitor.check_node(self)
end

#children ⇒ Array

return child nodes of a sexp node.

Returns:

  • (Array) —

    child nodes.



40
41
42
 
# File 'lib/code_analyzer/sexp.rb', line 40

def children
  find_all { | sexp | Sexp === sexp }
end

#class_name ⇒ Sexp

Get the class name of the class node.

s(:class,
  s(:const_ref, s(:@const, "User", s(1, 6))),
  nil,
  s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
)
    => s(:const_ref, s(:@const, "User", s(1, 6))),

Returns:

  • (Sexp) —

    class name node



156
157
158
159
160
 
# File 'lib/code_analyzer/sexp.rb', line 156

def class_name
  if :class == sexp_type
    self[1]
  end
end

#conditional_statement ⇒ Sexp

Get the conditional statement of if node.

s(:if,
  s(:var_ref, s(:@kw, "true", s(1, 3))),
  s(:stmts_add, s(:stmts_new), s(:void_stmt)),
  nil
)
    => s(:var_ref, s(:@kw, "true", s(1, 3))),

Returns:

  • (Sexp) —

    conditional statement of if node



332
333
334
335
336
 
# File 'lib/code_analyzer/sexp.rb', line 332

def conditional_statement
  if [:if, :unless, :elsif, :ifop, :if_mod, :unless_mod].include? sexp_type
    self[1]
  end
end

#const? ⇒ Boolean

check if the self node is a const.

Returns:

  • (Boolean) 


845
846
847
 
# File 'lib/code_analyzer/sexp.rb', line 845

def const?
  :@const == self.sexp_type || ([:var_ref, :vcall].include?(self.sexp_type) && :@const == self[1].sexp_type)
end

#exception_classes ⇒ Object

Get expcetion class of rescue node.

s(:rescue,
  s(
    s(:var_ref,
      s(:@const, "CustomException", s(1, 17))
    )
  ),
  nil,
  s(:stmts_add, s(:stmts_new), s(:void_stmt)),
  nil
)
    => s(s(:var_ref, s(:@const, "CustomException", s(1, 17))))



542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
 
# File 'lib/code_analyzer/sexp.rb', line 542

def exception_classes
  if :rescue == sexp_type
    return [] unless self[1]
    if :mrhs_add == self[1].sexp_type
      exceptions = Array.new(self[1][2])
      arg_nodes = self[1][1][1]
      while :args_add == arg_nodes.sexp_type
        exceptions.unshift arg_nodes[2]
        arg_nodes = arg_nodes[1]
      end
      exceptions
    else
      self[1]
    end
  end
end

#exception_variable ⇒ Object

Get exception variable of rescue node.

s(:rescue,
  nil,
  s(:var_field, s(:@ident, "e", s(1, 20))),
  s(:stmts_add, s(:stmts_new), s(:void_stmt)),
  nil
)
    => s(:var_field, s(:@ident, "e", s(1, 20)))



568
569
570
571
572
 
# File 'lib/code_analyzer/sexp.rb', line 568

def exception_variable
  if :rescue == sexp_type
    self[2]
  end
end

#grep_node(options) ⇒ Object

grep all the recursive child nodes with conditions, and yield the first match node.

options is the grep conditions, like

sexp_type: :call,
receiver: s(:const, Post),
message: [:find, :new]

the condition key is one of :sexp_type, :receiver, :message, and to_s, the condition value can be Symbol, Array or Sexp.

Parameters:

  • options (Hash) —

    grep conditions



92
93
94
95
96
 
# File 'lib/code_analyzer/sexp.rb', line 92

def grep_node(options)
  result = CodeAnalyzer::Nil.new
  grep_nodes(options) { |node| result = node; break; }
  result
end

#grep_nodes(options) ⇒ Object

grep all the recursive child nodes with conditions, and yield each match node.

options is the grep conditions, like

sexp_type: :call,
receiver: "Post",
message: ["find", "new"]
to_s: "devise"

the condition key is one of :sexp_type, :receiver, :message, :to_s, the condition value can be Symbol, Array or Sexp.

Parameters:

  • options (Hash) —

    grep conditions



65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/code_analyzer/sexp.rb', line 65

def grep_nodes(options)
  sexp_type = options[:sexp_type]
  receiver = options[:receiver]
  message = options[:message]
  to_s = options[:to_s]
  self.recursive_children do |child|
    if (!sexp_type || (sexp_type.is_a?(Array) ? sexp_type.include?(child.sexp_type) : sexp_type == child.sexp_type)) &&
       (!receiver || (receiver.is_a?(Array) ? receiver.include?(child.receiver.to_s) : receiver == child.receiver.to_s)) &&
       (!message || (message.is_a?(Array) ? message.include?(child.message.to_s) : message == child.message.to_s)) &&
       (!to_s || (to_s.is_a?(Array) ? to_s.include?(child.to_s) : to_s == child.to_s))
      yield child
    end
  end
end

#grep_nodes_count(options) ⇒ Integer

grep all the recursive child nodes with conditions, and get the count of match nodes.

Parameters:

  • options (Hash) —

    grep conditions

Returns:

  • (Integer) —

    the count of metch nodes



102
103
104
105
106
 
# File 'lib/code_analyzer/sexp.rb', line 102

def grep_nodes_count(options)
  count = 0
  grep_nodes(options) { |node| count += 1 }
  count
end

#hash_keys ⇒ Array

Get the hash keys.

s(:hash,
  s(:assoclist_from_args,
    s(
      s(:assoc_new, s(:@label, "first_name:", s(1, 1)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14))))),
      s(:assoc_new, s(:@label, "last_name:", s(1, 24)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Huang", s(1, 36)))))
    )
  )
)
    => ["first_name", "last_name"]

Returns:

  • (Array) —

    hash keys



642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
 
# File 'lib/code_analyzer/sexp.rb', line 642

def hash_keys
  pair_nodes = case sexp_type
               when :bare_assoc_hash
                 self[1]
               when :hash
                 self[1][1]
               else
               end
  if pair_nodes
    keys = []
    pair_nodes.size.times do |i|
      keys << pair_nodes[i][1].to_s
    end
    keys
  end
end

#hash_size ⇒ Integer

Get hash size.

s(:hash,
  s(:assoclist_from_args,
    s(
      s(:assoc_new, s(:@label, "first_name:", s(1, 1)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14))))),
      s(:assoc_new, s(:@label, "last_name:", s(1, 24)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Huang", s(1, 36)))))
    )
  )
)
    => 2

Returns:

  • (Integer) —

    hash size



618
619
620
621
622
623
624
625
626
627
 
# File 'lib/code_analyzer/sexp.rb', line 618

def hash_size
  case sexp_type
  when :hash
    self[1].hash_size
  when :assoclist_from_args
    self[1].size
  when :bare_assoc_hash
    self[1].size
  end
end

#hash_value(key) ⇒ Sexp

Get hash value node.

s(:hash,
  s(:assoclist_from_args,
    s(
      s(:assoc_new, s(:@label, "first_name:", s(1, 1)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14))))),
      s(:assoc_new, s(:@label, "last_name:", s(1, 24)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Huang", s(1, 36)))))
    )
  )
)
    => s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14))))

Returns:

  • (Sexp) —

    hash value node



587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
 
# File 'lib/code_analyzer/sexp.rb', line 587

def hash_value(key)
  pair_nodes = case sexp_type
               when :bare_assoc_hash
                 self[1]
               when :hash
                 self[1][1]
               else
               end
  if pair_nodes
    pair_nodes.size.times do |i|
      if key == pair_nodes[i][1].to_s
        return pair_nodes[i][2]
      end
    end
  end
  CodeAnalyzer::Nil.new
end

#hash_values ⇒ Array

Get the hash values.

s(:hash,
  s(:assoclist_from_args,
    s(
      s(:assoc_new, s(:@label, "first_name:", s(1, 1)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14))))),
      s(:assoc_new, s(:@label, "last_name:", s(1, 24)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Huang", s(1, 36)))))
    )
  )
)
    => [
         s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14)))),
         s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Huang", s(1, 36))))
       ]

Returns:

  • (Array) —

    hash values



675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
 
# File 'lib/code_analyzer/sexp.rb', line 675

def hash_values
  pair_nodes = case sexp_type
               when :bare_assoc_hash
                 self[1]
               when :hash
                 self[1][1]
               else
               end
  if pair_nodes
    values = []
    pair_nodes.size.times do |i|
      values << pair_nodes[i][2]
    end
    values
  end
end

#left_value ⇒ Symbol

Get the left value of the assign node.

s(:assign,
  s(:var_field, s(:@ident, "user", s(1, 0))),
  s(:var_ref, s(:@ident, "current_user", s(1, 7)))
)
    => s(:var_field, s(:@ident, "user", s(1, 0))),

Returns:

  • (Symbol) —

    left value of lasgn or iasgn node



187
188
189
190
191
 
# File 'lib/code_analyzer/sexp.rb', line 187

def left_value
  if :assign == sexp_type
    self[1]
  end
end

#line_number ⇒ Object

return the line number of a sexp node.

s(:@ident, "test", s(2, 12)
  => 2



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/code_analyzer/sexp.rb', line 16

def line_number
  case sexp_type
  when :def, :defs, :command, :command_call, :call, :fcall, :method_add_arg, :method_add_block,
       :var_ref, :vcall, :const_ref, :const_path_ref, :class, :module,
       :if, :unless, :elsif, :ifop, :if_mod, :unless_mod, :binary,
       :alias, :symbol_literal, :symbol, :aref, :hash, :assoc_new, :string_literal,
       :massign
    self[1].line_number
  when :assoclist_from_args, :bare_assoc_hash
    self[1][0].line_number
  when :string_add, :opassign
    self[2].line_number
  when :array
    array_values.first.line_number
  when :mlhs_add
    self.last.line_number
  else
    self.last.first if self.last.is_a? Array
  end
end

#message ⇒ Symbol

Get the message node.

s(:command,
  s(:@ident, "has_many", s(1, 0)),
  s(:args_add_block,
    s(:args_add, s(:args_new),
      s(:symbol_literal, s(:symbol, s(:@ident, "projects", s(1, 10))))
    ),
    false
  )
)
    => s(:@ident, "has_many", s(1, 0)),

Returns:

  • (Symbol) —

    message node



222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/code_analyzer/sexp.rb', line 222

def message
  case sexp_type
  when :command, :fcall
    self[1]
  when :binary
    self[2]
  when :command_call, :field, :call
    self[3]
  when :method_add_arg, :method_add_block
    self[1].message
  end
end

#method_name ⇒ Sexp

Get the method name of def node.

s(:def,
  s(:@ident, "show", s(1, 4)),
  s(:params, nil, nil, nil, nil, nil),
  s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
)
    => s(:@ident, "show", s(1, 4)),

Returns:

  • (Sexp) —

    method name node



395
396
397
398
399
400
401
402
403
 
# File 'lib/code_analyzer/sexp.rb', line 395

def method_name
  case sexp_type
  when :def
    self[1]
  when :defs
    self[3]
  else
  end
end

#module_name ⇒ Sexp

Get the module name of the module node.

s(:module,
  s(:const_ref, s(:@const, "Admin", s(1, 7))),
  s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
)
    => s(:const_ref, s(:@const, "Admin", s(1, 7))),

Returns:

  • (Sexp) —

    module name node



140
141
142
143
144
 
# File 'lib/code_analyzer/sexp.rb', line 140

def module_name
  if :module == sexp_type
    self[1]
  end
end

#new_method ⇒ Object

new method for alias node.

s(:alias,
  s(:symbol_literal, s(:@ident, "new", s(1, 6))),
  s(:symbol_literal, s(:@ident, "old", s(1, 10)))
)
    => s(:symbol_literal, s(:@ident, "new", s(1, 6))),



782
783
784
 
# File 'lib/code_analyzer/sexp.rb', line 782

def new_method
  self[1]
end

#old_method ⇒ Object

old method for alias node.

s(:alias,
  s(:symbol_literal, s(:@ident, "new", s(1, 6))),
  s(:symbol_literal, s(:@ident, "old", s(1, 10)))
)
    => s(:symbol_literal, s(:@ident, "old", s(1, 10))),



771
772
773
 
# File 'lib/code_analyzer/sexp.rb', line 771

def old_method
  self[2]
end

#present? ⇒ Boolean

true

Returns:

  • (Boolean) 


850
851
852
 
# File 'lib/code_analyzer/sexp.rb', line 850

def present?
  true
end

#receiver ⇒ Sexp

Get receiver node.

s(:call,
  s(:var_ref,
    s(:@ident, "user", s(1, 0))
  ),
  :".",
  s(:@ident, "name", s(1, 5))
)
    => s(:var_ref,
         s(:@ident, "user", s(1, 0))
       )

Returns:

  • (Sexp) —

    receiver node



122
123
124
125
126
127
128
129
 
# File 'lib/code_analyzer/sexp.rb', line 122

def receiver
  case sexp_type
  when :assign, :field, :call, :binary, :command_call
    self[1]
  when :method_add_arg, :method_add_block
    self[1].receiver
  end
end

#recursive_children ⇒ Object

recursively find all child nodes, and yeild each child node.



45
46
47
48
49
50
 
# File 'lib/code_analyzer/sexp.rb', line 45

def recursive_children
  children.each do |child|
    yield child
    child.recursive_children { |c| yield c }
  end
end

#remove_line_and_column ⇒ Object

remove the line and column info from sexp.



860
861
862
863
864
865
866
867
868
869
870
871
872
 
# File 'lib/code_analyzer/sexp.rb', line 860

def remove_line_and_column
  node = self.clone
  last_node = node.last
  if Sexp === last_node && last_node.size == 2 && last_node.first.is_a?(Integer) && last_node.last.is_a?(Integer)
    node.delete_at(-1)
  end
  node.sexp_body.each_with_index do |child, index|
    if Sexp === child
      node[index+1] = child.remove_line_and_column
    end
  end
  node
end

#right_value ⇒ Sexp

Get the right value of assign node.

s(:assign,
  s(:var_field, s(:@ident, "user", s(1, 0))),
  s(:var_ref, s(:@ident, "current_user", s(1, 7)))
)
    => s(:var_ref, s(:@ident, "current_user", s(1, 7)))

Returns:

  • (Sexp) —

    right value of assign node



202
203
204
205
206
 
# File 'lib/code_analyzer/sexp.rb', line 202

def right_value
  if :assign == sexp_type
    self[2]
  end
end

#statements ⇒ Array

Get all statements nodes.

s(:bodystmt,
  s(:stmts_add,
    s(:stmts_add, s(:stmts_new),
      s(:def,
        s(:@ident, "login?", s(1, 16)),
        s(:params, nil, nil, nil, nil, nil),
        s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
      )
    ),
    s(:def,
      s(:@ident, "admin?", s(1, 33)),
      s(:params, nil, nil, nil, nil, nil),
      s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
    )
  ), nil, nil, nil
)
    => [
         s(:def,
           s(:@ident, "login?", s(1, 16)),
           s(:params, nil, nil, nil, nil, nil),
           s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
         ),
         s(:def,
           s(:@ident, "admin?", s(1, 33)),
           s(:params, nil, nil, nil, nil, nil),
           s(:bodystmt, s(:stmts_add, s(:stmts_new), s(:void_stmt)), nil, nil, nil)
         )
       ]

Returns:

  • (Array) —

    all statements



507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
 
# File 'lib/code_analyzer/sexp.rb', line 507

def statements
  stmts = []
  node = case sexp_type
         when :do_block, :brace_block
           self[2]
         when :bodystmt
           self[1]
         else
         end
  if node
    while true
      if :stmts_add == node.sexp_type && s(:void_stmt) != node[2]
        stmts.unshift node[2]
        node = node[1]
      else
        break
      end
    end
  end
  stmts
end

#to_object ⇒ Object

To object.

s(:array,
  s(:args_add,
    s(:args_add, s(:args_new), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "first_name", s(1, 2))))),
    s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "last_name", s(1, 16))))
  )
)
    => ["first_name", "last_name"]

Returns:

  • (Object) 


797
798
799
800
801
802
803
804
 
# File 'lib/code_analyzer/sexp.rb', line 797

def to_object
  case sexp_type
  when :array
    array_values.map(&:to_s)
  else
    to_s
  end
end

#to_s ⇒ String

to_s.

Returns:

  • (String) —

    to_s



809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
 
# File 'lib/code_analyzer/sexp.rb', line 809

def to_s
  case sexp_type
  when :string_literal, :xstring_literal, :string_content, :const_ref, :symbol_literal, :symbol,
       :args_add_block, :var_ref, :vcall, :var_field,
       :@ident, :@tstring_content, :@const, :@ivar, :@kw, :@gvar, :@cvar
    self[1].to_s
  when :string_add
    if s(:string_content) == self[1]
      self[2].to_s
    else
      self[1].to_s
    end
  when :args_add
    if s(:args_new) == self[1]
      self[2].to_s
    else
      self[1].to_s
    end
  when :qwords_add
    self[2].to_s
  when :word_add
    self[2].to_s
  when :const_path_ref
    "#{self[1]}::#{self[2]}"
  when :@label
    self[1].to_s[0..-2]
  when :aref
    "#{self[1]}[#{self[2]}]"
  when :call, :field
    "#{self.receiver}.#{self.message}"
  else
    ""
  end
end