Class: SyntaxTree::Params

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

Overview

Params represents defining parameters on a method or lambda.

def method(param) end

Defined Under Namespace

Classes: KeywordFormatter, KeywordRestFormatter, OptionalFormatter

Instance Attribute Summary collapse

Attributes inherited from Node

#location

Instance Method Summary collapse

Methods inherited from Node

#construct_keys, #pretty_print, #to_json

Constructor Details

#initialize(requireds: [], optionals: [], rest: nil, posts: [], keywords: [], keyword_rest: nil, block: nil, location:, comments: []) ⇒ Params

Returns a new instance of Params.



6820
6821
6822
6823
6824
6825
6826
6827
6828
6829
6830
6831
6832
6833
6834
6835
6836
6837
6838
6839
6840
 
# File 'lib/syntax_tree/node.rb', line 6820

def initialize(
  requireds: [],
  optionals: [],
  rest: nil,
  posts: [],
  keywords: [],
  keyword_rest: nil,
  block: nil,
  location:,
  comments: []
)
  @requireds = requireds
  @optionals = optionals
  @rest = rest
  @posts = posts
  @keywords = keywords
  @keyword_rest = keyword_rest
  @block = block
  @location = location
  @comments = comments
end

Instance Attribute Details

#block ⇒ Object (readonly)

[nil | BlockArg] the optional block parameter



6815
6816
6817
 
# File 'lib/syntax_tree/node.rb', line 6815

def block
  @block
end

#comments ⇒ Object (readonly)

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



6818
6819
6820
 
# File 'lib/syntax_tree/node.rb', line 6818

def comments
  @comments
end

#keyword_rest ⇒ Object (readonly)

[nil | :nil | KwRestParam] the optional keyword rest parameter



6812
6813
6814
 
# File 'lib/syntax_tree/node.rb', line 6812

def keyword_rest
  @keyword_rest
end

#keywords ⇒ Object (readonly)

[Array[ [ Ident, nil | untyped ] ]] any keyword parameters and their optional default values



6809
6810
6811
 
# File 'lib/syntax_tree/node.rb', line 6809

def keywords
  @keywords
end

#optionals ⇒ Object (readonly)

[Array[ [ Ident, untyped ] ]] any optional parameters and their default values



6797
6798
6799
 
# File 'lib/syntax_tree/node.rb', line 6797

def optionals
  @optionals
end

#posts ⇒ Object (readonly)

[Array[ Ident ]] any positional parameters that exist after a rest parameter



6805
6806
6807
 
# File 'lib/syntax_tree/node.rb', line 6805

def posts
  @posts
end

#requireds ⇒ Object (readonly)

[Array[ Ident ]] any required parameters



6793
6794
6795
 
# File 'lib/syntax_tree/node.rb', line 6793

def requireds
  @requireds
end

#rest ⇒ Object (readonly)

[nil | ArgsForward | ExcessedComma | RestParam] the optional rest parameter



6801
6802
6803
 
# File 'lib/syntax_tree/node.rb', line 6801

def rest
  @rest
end

Instance Method Details

#accept(visitor) ⇒ Object 



6851
6852
6853
 
# File 'lib/syntax_tree/node.rb', line 6851

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

#child_nodes ⇒ Object Also known as: deconstruct 



6855
6856
6857
6858
6859
6860
6861
6862
6863
6864
6865
 
# File 'lib/syntax_tree/node.rb', line 6855

def child_nodes
  [
    *requireds,
    *optionals.flatten(1),
    rest,
    *posts,
    *keywords.flatten(1),
    (keyword_rest if keyword_rest != :nil),
    block
  ]
end

#deconstruct_keys(_keys) ⇒ Object 



6869
6870
6871
6872
6873
6874
6875
6876
6877
6878
6879
6880
6881
 
# File 'lib/syntax_tree/node.rb', line 6869

def deconstruct_keys(_keys)
  {
    location: location,
    requireds: requireds,
    optionals: optionals,
    rest: rest,
    posts: posts,
    keywords: keywords,
    keyword_rest: keyword_rest,
    block: block,
    comments: comments
  }
end

#empty? ⇒ Boolean

Params nodes are the most complicated in the tree. Occasionally you want to know if they are "empty", which means not having any parameters declared. This logic accesses every kind of parameter and determines if it's missing.

Returns:

  • (Boolean) 


6846
6847
6848
6849
 
# File 'lib/syntax_tree/node.rb', line 6846

def empty?
  requireds.empty? && optionals.empty? && !rest && posts.empty? &&
    keywords.empty? && !keyword_rest && !block
end

#format(q) ⇒ Object 



6883
6884
6885
6886
6887
6888
6889
6890
6891
6892
6893
6894
6895
6896
6897
6898
6899
6900
6901
6902
6903
6904
6905
6906
6907
6908
6909
6910
6911
6912
6913
6914
 
# File 'lib/syntax_tree/node.rb', line 6883

def format(q)
  parts = [
    *requireds,
    *optionals.map { |(name, value)| OptionalFormatter.new(name, value) }
  ]

  parts << rest if rest && !rest.is_a?(ExcessedComma)
  parts += [
    *posts,
    *keywords.map { |(name, value)| KeywordFormatter.new(name, value) }
  ]

  parts << KeywordRestFormatter.new(keyword_rest) if keyword_rest
  parts << block if block

  contents = -> do
    q.seplist(parts) { |part| q.format(part) }
    q.format(rest) if rest.is_a?(ExcessedComma)
  end

  if ![Def, Defs, DefEndless].include?(q.parent.class) || parts.empty?
    q.nest(0, &contents)
  else
    q.group(0, "(", ")") do
      q.indent do
        q.breakable("")
        contents.call
      end
      q.breakable("")
    end
  end
end