Class: SyntaxTree::HshPtn

Inherits:
Node
  • Object
show all
Defined in:
lib/syntax_tree/node.rb

Overview

HshPtn represents matching against a hash pattern using the Ruby 2.7+ pattern matching syntax.

case value
in { key: }
end

Defined Under Namespace

Classes: KeywordFormatter, KeywordRestFormatter

Instance Attribute Summary collapse

Attributes inherited from Node

#location

Instance Method Summary collapse

Methods inherited from Node

#construct_keys, #end_char, #pretty_print, #start_char, #to_json, #to_mermaid

Constructor Details

#initialize(constant:, keywords:, keyword_rest:, location:) ⇒ HshPtn

Returns a new instance of HshPtn.



6051
6052
6053
6054
6055
6056
6057
 
# File 'lib/syntax_tree/node.rb', line 6051

def initialize(constant:, keywords:, keyword_rest:, location:)
  @constant = constant
  @keywords = keywords
  @keyword_rest = keyword_rest
  @location = location
  @comments = []
end

Instance Attribute Details

#comments ⇒ Object (readonly)

Array[ Comment | EmbDoc ]

the comments attached to this node



6049
6050
6051
 
# File 'lib/syntax_tree/node.rb', line 6049

def comments
  @comments
end

#constant ⇒ Object (readonly)

nil | Node

the optional constant wrapper



6039
6040
6041
 
# File 'lib/syntax_tree/node.rb', line 6039

def constant
  @constant
end

#keyword_rest ⇒ Object (readonly)

nil | VarField

an optional parameter to gather up all remaining keywords



6046
6047
6048
 
# File 'lib/syntax_tree/node.rb', line 6046

def keyword_rest
  @keyword_rest
end

#keywords ⇒ Object (readonly)

Array[ [DynaSymbol | Label, nil | Node

]] the set of tuples

representing the keywords that should be matched against in the pattern



6043
6044
6045
 
# File 'lib/syntax_tree/node.rb', line 6043

def keywords
  @keywords
end

Instance Method Details

#===(other) ⇒ Object 



6144
6145
6146
6147
6148
6149
6150
6151
 
# File 'lib/syntax_tree/node.rb', line 6144

def ===(other)
  other.is_a?(HshPtn) && constant === other.constant &&
    keywords.length == other.keywords.length &&
    keywords
      .zip(other.keywords)
      .all? { |left, right| ArrayMatch.call(left, right) } &&
    keyword_rest === other.keyword_rest
end

#accept(visitor) ⇒ Object 



6059
6060
6061
 
# File 'lib/syntax_tree/node.rb', line 6059

def accept(visitor)
  visitor.visit_hshptn(self)
end

#child_nodes ⇒ Object Also known as: deconstruct 



6063
6064
6065
 
# File 'lib/syntax_tree/node.rb', line 6063

def child_nodes
  [constant, *keywords.flatten(1), keyword_rest]
end

#copy(constant: nil, keywords: nil, keyword_rest: nil, location: nil) ⇒ Object 



6067
6068
6069
6070
6071
6072
6073
6074
6075
6076
6077
6078
 
# File 'lib/syntax_tree/node.rb', line 6067

def copy(constant: nil, keywords: nil, keyword_rest: nil, location: nil)
  node =
    HshPtn.new(
      constant: constant || self.constant,
      keywords: keywords || self.keywords,
      keyword_rest: keyword_rest || self.keyword_rest,
      location: location || self.location
    )

  node.comments.concat(comments.map(&:copy))
  node
end

#deconstruct_keys(_keys) ⇒ Object 



6082
6083
6084
6085
6086
6087
6088
6089
6090
 
# File 'lib/syntax_tree/node.rb', line 6082

def deconstruct_keys(_keys)
  {
    constant: constant,
    keywords: keywords,
    keyword_rest: keyword_rest,
    location: location,
    comments: comments
  }
end

#format(q) ⇒ Object 



6092
6093
6094
6095
6096
6097
6098
6099
6100
6101
6102
6103
6104
6105
6106
6107
6108
6109
6110
6111
6112
6113
6114
6115
6116
6117
6118
6119
6120
6121
6122
6123
6124
6125
6126
6127
6128
6129
6130
6131
6132
6133
6134
6135
6136
6137
6138
6139
6140
6141
6142
 
# File 'lib/syntax_tree/node.rb', line 6092

def format(q)
  parts = keywords.map { |(key, value)| KeywordFormatter.new(key, value) }
  parts << KeywordRestFormatter.new(keyword_rest) if keyword_rest
  nested = PATTERNS.include?(q.parent.class)

  # If there is a constant, we're going to format to have the constant name
  # first and then use brackets.
  if constant
    q.group do
      q.format(constant)
      q.text("[")
      q.indent do
        q.breakable_empty
        format_contents(q, parts, nested)
      end
      q.breakable_empty
      q.text("]")
    end
    return
  end

  # If there's nothing at all, then we're going to use empty braces.
  if parts.empty?
    q.text("{}")
    return
  end

  # If there's only one pair, then we'll just print the contents provided
  # we're not inside another pattern.
  if !nested && parts.size == 1
    format_contents(q, parts, nested)
    return
  end

  # Otherwise, we're going to always use braces to make it clear it's a hash
  # pattern.
  q.group do
    q.text("{")
    q.indent do
      q.breakable_space
      format_contents(q, parts, nested)
    end

    if q.target_ruby_version < Formatter::SemanticVersion.new("2.7.3")
      q.text(" }")
    else
      q.breakable_space
      q.text("}")
    end
  end
end