Class: Prism::Merge::RecursiveMergePolicy

Inherits:
Object
  • Object
show all
Defined in:
lib/prism/merge/recursive_merge_policy.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(merger:) ⇒ RecursiveMergePolicy

Returns a new instance of RecursiveMergePolicy.



8
9
10
 
# File 'lib/prism/merge/recursive_merge_policy.rb', line 8

def initialize(merger:)
  @merger = merger
end

Instance Attribute Details

#merger ⇒ Object (readonly)

Returns the value of attribute merger.



6
7
8
 
# File 'lib/prism/merge/recursive_merge_policy.rb', line 6

def merger
  @merger
end

Instance Method Details

#body_has_mergeable_statements?(body) ⇒ Boolean

Returns:

  • (Boolean) 


39
40
41
42
43
44
45
 
# File 'lib/prism/merge/recursive_merge_policy.rb', line 39

def body_has_mergeable_statements?(body)
  return false unless body
  return false unless body.type.to_s == 'statements_node'
  return false if body.body.empty?

  body.body.any? { |statement| mergeable_statement?(statement) }
end

#mergeable_statement?(node) ⇒ Boolean

Returns:

  • (Boolean) 


47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/prism/merge/recursive_merge_policy.rb', line 47

def mergeable_statement?(node)
  ct = NodeTypeNormalizer.canonical_type(node.type.to_s, :prism)
  %i[
    call
    def
    class
    module
    singleton_class
    const
    local_var
    ivar
    cvar
    gvar
    multi_write
    if
    unless
    case
    begin
  ].include?(ct)
end

#should_merge?(template_node:, dest_node:) ⇒ Boolean

Returns:

  • (Boolean) 


12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/prism/merge/recursive_merge_policy.rb', line 12

def should_merge?(template_node:, dest_node:)
  return false unless template_node && dest_node
  return false if merger.instance_variable_get(:@current_depth) >= merger.max_recursion_depth

  actual_template = unwrap_node(template_node)
  actual_dest = unwrap_node(dest_node)
  return false unless canonical_type_of(actual_template) == canonical_type_of(actual_dest)
  return false unless multiline_wrapper?(actual_template) && multiline_wrapper?(actual_dest)

  case canonical_type_of(actual_template)
  when :class, :module, :singleton_class
    true
  when :call
    return false unless actual_template.block && actual_dest.block

    template_body = actual_template.block.body
    dest_body = actual_dest.block.body

    body_has_mergeable_statements?(template_body) && body_has_mergeable_statements?(dest_body)
  when :begin
    !!(merger.send(:begin_node_has_clause_or_body?,
                   actual_template) && merger.send(:begin_node_has_clause_or_body?, actual_dest))
  else
    false
  end
end