Class: Sexp

Inherits:
Object
  • Object
show all
Defined in:
lib/rails_best_practices/core_ext/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



297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 297

def all
  nodes = []
  case sexp_type
  when :args_add_block, :array
    if self[1].sexp_type == :args_new
      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
  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



363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 363

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



277
278
279
280
281
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 277

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



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 250

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



654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 654

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



688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 688

def array_values
  if :array == sexp_type
    if nil == self[1]
      []
    elsif :qwords_add == self[1].sexp_type
      self[1].array_values
    else
      arguments.all
    end
  elsif :qwords_add
    values = []
    node = self
    while true
      if :qwords_add == node.sexp_type
        values.unshift node[2]
        node = node[1]
      elsif :qwords_new == node.sexp_type
        break
      end
    end
    values
  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



170
171
172
173
174
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 170

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

#blank? ⇒ Boolean

false

Returns:

  • (Boolean) 


807
808
809
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 807

def blank?
  false
end

#block ⇒ 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



464
465
466
467
468
469
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 464

def block
  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



427
428
429
430
431
432
433
434
435
436
437
438
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 427

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

#children ⇒ Array

return child nodes of a sexp node.

Returns:

  • (Array) —

    child nodes.



38
39
40
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 38

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



154
155
156
157
158
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 154

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



328
329
330
331
332
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 328

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

#const? ⇒ Boolean

check if the self node is a const.

Returns:

  • (Boolean) 


797
798
799
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 797

def const?
  :@const == self.sexp_type || ([:var_ref, :vcall].include?(self.sexp_type) && :@const == self[1].sexp_type)
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,
:subject => s(:const, Post),
:message => [:find, :new]

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

Parameters:

  • options (Hash) —

    grep conditions



90
91
92
93
94
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 90

def grep_node(options)
  result = RailsBestPractices::Core::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,
:subject => "Post",
:message => ["find", "new"]
:to_s => "devise"

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

Parameters:

  • options (Hash) —

    grep conditions



63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 63

def grep_nodes(options)
  sexp_type = options[:sexp_type]
  subject = options[:subject]
  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)) &&
       (!subject || (subject.is_a?(Array) ? subject.include?(child.subject.to_s) : subject == child.subject.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



100
101
102
103
104
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 100

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



593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 593

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



569
570
571
572
573
574
575
576
577
578
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 569

def hash_size
  case sexp_type
  when :hash
    self[1] && self[1].hash_size || 0
  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



538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 538

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
  RailsBestPractices::Core::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



626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 626

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



185
186
187
188
189
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 185

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

#line ⇒ Object

return the line number of a sexp node.

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



23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 23

def line
  if [: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, :binary,
    :alias, :symbol_literal, :symbol, :aref].include? sexp_type
    self[1].line
  elsif :array == sexp_type
    array_values.first.line
  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



220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 220

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



391
392
393
394
395
396
397
398
399
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 391

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



138
139
140
141
142
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 138

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))),



730
731
732
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 730

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))),



719
720
721
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 719

def old_method
  self[2]
end

#prepare(visitor) ⇒ Object

prepare current node.

Parameters:



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

def prepare(visitor)
  visitor.prepare(self)
end

#present? ⇒ Boolean

true

Returns:

  • (Boolean) 


802
803
804
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 802

def present?
  true
end

#recursive_children ⇒ Object

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



43
44
45
46
47
48
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 43

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.



812
813
814
815
816
817
818
819
820
821
822
823
824
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 812

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

#review(visitor) ⇒ Object

prepare current node.

Parameters:



15
16
17
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 15

def review(visitor)
  visitor.review(self)
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



200
201
202
203
204
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 200

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



503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 503

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

#subject ⇒ Sexp

Get subject 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) —

    subject node



120
121
122
123
124
125
126
127
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 120

def subject
  case sexp_type
  when :assign, :field, :call, :binary, :command_call
    self[1]
  when :method_add_arg, :method_add_block
    self[1].subject
  end
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) 


745
746
747
748
749
750
751
752
753
754
755
756
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 745

def to_object
  case sexp_type
  when :array
    if nil == self[1]
      []
    else
      arguments.all.map(&:to_s)
    end
  else
    to_s
  end
end

#to_s ⇒ String

to_s.

Returns:

  • (String) —

    to_s



761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
 
# File 'lib/rails_best_practices/core_ext/sexp.rb', line 761

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
    if s(:qwords_new) == self[1]
      self[2].to_s
    else
      self[1].to_s
    end
  when :const_path_ref
    "#{self[1]}::#{self[2]}"
  when :@label
    self[1].to_s[0..-2]
  when :aref
    "#{self[1]}[#{self[2]}]"
  else
    ""
  end
end