class SyntaxTree::HshPtn

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

case value
in { key: }
end

Attributes

comments[R]

Array[ Comment | EmbDoc ]: the comments attached to this node

constant[R]

nil | VarRef | ConstPathRef: the optional constant wrapper

keyword_rest[R]

nil | VarField: an optional parameter to gather up all remaining keywords

keywords[R]

Array[ [DynaSymbol | Label, nil | Node: ]] the set of tuples

representing the keywords that should be matched against in the pattern

Public Class Methods

new(constant:, keywords:, keyword_rest:, location:) click to toggle source

# File lib/syntax_tree/node.rb, line 6054
def initialize(constant:, keywords:, keyword_rest:, location:)
  @constant = constant
  @keywords = keywords
  @keyword_rest = keyword_rest
  @location = location
  @comments = []
end

Public Instance Methods

===(other) click to toggle source

# File lib/syntax_tree/node.rb, line 6147
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) click to toggle source

# File lib/syntax_tree/node.rb, line 6062
def accept(visitor)
  visitor.visit_hshptn(self)
end

child_nodes() click to toggle source

# File lib/syntax_tree/node.rb, line 6066
def child_nodes
  [constant, *keywords.flatten(1), keyword_rest]
end

Also aliased as: deconstruct

copy(constant: nil, keywords: nil, keyword_rest: nil, location: nil) click to toggle source

# File lib/syntax_tree/node.rb, line 6070
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()

Alias for: child_nodes

deconstruct_keys(_keys) click to toggle source

# File lib/syntax_tree/node.rb, line 6085
def deconstruct_keys(_keys)
  {
    constant: constant,
    keywords: keywords,
    keyword_rest: keyword_rest,
    location: location,
    comments: comments
  }
end

format(q) click to toggle source

# File lib/syntax_tree/node.rb, line 6095
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