123456789_123456789_123456789_123456789_123456789_

Class: RuboCop::AST::MasgnNode

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Node, NodePattern::Macros, Parser::AST::Node
Instance Chain:
self, Node, Descendence, Sexp, Parser::AST::Node
Inherits: RuboCop::AST::Node
Defined in: lib/rubocop/ast/node/masgn_node.rb

Overview

A node extension for masgn nodes. This will be used in place of a plain node when the builder constructs the AST, making its methods available to all assignment nodes within RuboCop.

Constant Summary

Node - Inherited

ASSIGNMENTS, BASIC_CONDITIONALS, BASIC_LITERALS, COMPARISON_OPERATORS, COMPOSITE_LITERALS, CONDITIONALS, EMPTY_CHILDREN, EMPTY_PROPERTIES, EQUALS_ASSIGNMENTS, FALSEY_LITERALS, GROUP_FOR_TYPE, IMMUTABLE_LITERALS, KEYWORDS, LITERALS, LITERAL_RECURSIVE_METHODS, LITERAL_RECURSIVE_TYPES, LOOP_TYPES, MUTABLE_LITERALS, OPERATOR_KEYWORDS, POST_CONDITION_LOOP_TYPES, REFERENCES, SHORTHAND_ASSIGNMENTS, SPECIAL_KEYWORDS, TRUTHY_LITERALS, VARIABLES

Class Method Summary

Node - Inherited

.new,
.def_recursive_literal_predicate

Define a recursive_? predicate method for the given node kind.

NodePattern::Macros - Extended

def_node_matcher

Define a method which applies a pattern to an AST node.
def_node_search

Define a method which recurses over the descendants of an AST node, checking whether any of them match the provided pattern.

Instance Attribute Summary

Node - Inherited

#any_block_type?, #any_def_type?, #any_match_pattern_type?, #argument?, #argument_type?, #assignment?, #basic_conditional?, #basic_literal?, #boolean_type?, #call_type?, #chained?, #complete?, #conditional?, #empty_source?, #equals_asgn?, #falsey_literal?, #guard_clause?, #immutable_literal?, #keyword?, #literal?,
#loop_keyword?
Note
loop { } is a normal method call and thus not a loop keyword.
#multiline?

Predicates.
#mutable_literal?, #numeric_type?, #operator_keyword?,
#parent

Returns the parent node, or nil if the receiver is a root node.
#parent?, #parenthesized_call?, #post_condition_loop?,
#pure?

Some expressions are evaluated for their value, some for their side effects, and some for both.
#range_type?, #reference?, #root?,
#send_type?

Most nodes are of 'send' type, so this method is defined separately to make this check as fast as possible.
#shorthand_asgn?, #single_line?, #special_keyword?, #truthy_literal?,
#value_used?

Some expressions are evaluated for their value, some for their side effects, and some for both If we know that an expression is useful only for its side effects, that means we can transform it in ways which preserve the side effects, but change the return value So, does the return value of this node matter? If we changed it to (…​; nil), might that affect anything?
#variable?, #begin_value_used?, #case_if_value_used?, #for_value_used?, #while_until_value_used?

Instance Method Summary

Node - Inherited

#ancestors

Returns an array of ancestor nodes.
#assignment_or_similar?

Some cops treat the shovel operator as a kind of assignment.
#class_constructor?, #class_definition?, #complete!, #const_name, #defined_module, #defined_module_name,
#each_ancestor

Calls the given block for each ancestor node from parent to root.
#first_line, #global_const?, #lambda?, #lambda_or_proc?, #last_line,
#left_sibling

Use is discouraged, this is a potentially slow method and can lead to even slower algorithms.
#left_siblings

Use is discouraged, this is a potentially slow method and can lead to even slower algorithms.
#line_count,
#loc?

Shortcut to safely check if a location is present.
#loc_is?

Shortcut to safely test a particular location, even if this location does not exist or is nil.
#match_guard_clause?, #module_definition?,
#node_parts

Common destructuring method.
#nonempty_line_count,
#parent_module_name

Searching the AST.
#proc?, #receiver, #recursive_basic_literal?, #recursive_literal?,
#right_sibling

Use is discouraged, this is a potentially slow method and can lead to even slower algorithms.
#right_siblings

Use is discouraged, this is a potentially slow method and can lead to even slower algorithms.
#sibling_index

Returns the index of the receiver node in its siblings.
#source
Note
 Some rare nodes may have no source, like s(:args) in foo {}.
#source_length, #source_range, #str_content, #struct_constructor?,
#type?

Determine if the node is one of several node types in a single query Allows specific single node types, as well as "grouped" types (e.g.
#updated

Override Node#updated so that AST::Processor does not try to mutate our ASTs.
#defined_module0, #new_class_or_module_block?, #parent_module_name_for_block, #parent_module_name_for_sclass, #parent_module_name_part, #visit_ancestors

Descendence - Included

#child_nodes

Returns an array of child nodes.
#descendants

Returns an array of descendant nodes.
#each_child_node

Calls the given block for each child node.
#each_descendant

Calls the given block for each descendant node with depth first order.
#each_node

Calls the given block for the receiver and each descendant node in depth-first order.

Sexp - Included

#s

Creates a Node with type type and children children.

Constructor Details

This class inherits a constructor from RuboCop::AST::Node

Instance Attribute Details

#multiple_rhs? ⇒ Boolean (readonly, private)

[ GitHub ] 

  


# File 'lib/rubocop/ast/node/masgn_node.rb', line 58



def multiple_rhs?
  expression.array_type? && !expression.bracketed?
end


  







Instance Method Details



  

    #assignments  ⇒ Array<Node> 
  



  

    
  





  
Returns:


    
  
  • 
    (Array<Node>)
—    
    

    the assignment nodes of the multiple assignment
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/rubocop/ast/node/masgn_node.rb', line 16



def assignments
  lhs.assignments
end


  








  

    #expression  ⇒ Node 
    Also known as: #rhs
  



  

    


The RHS (right hand side) of the multiple assignment. This returns
the nodes as parsed: either a single node if the RHS has a single value,
or an array node containing multiple nodes.











Note



Due to how parsing works, expression will return the same for
a, b = x, y and a, b = [x, y].







  





  
Returns:


    
  
  • 
    (Node)
—    
    

    the right hand side of a multiple assignment.
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/rubocop/ast/node/masgn_node.rb', line 39



def expression
  node_parts[1]
end


  








  

    #lhs  ⇒ MlhsNode 
  



  

    
  





  
Returns:





  [ GitHub ]


  

  


# File 'lib/rubocop/ast/node/masgn_node.rb', line 10



def lhs
  # The first child is a `mlhs` node
  node_parts[0]
end


  








  

    #names  ⇒ Array<Symbol> 
  



  

    
  





  
Returns:


    
  
  • 
    (Array<Symbol>)
—    
    

    names of all the variables being assigned
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/rubocop/ast/node/masgn_node.rb', line 21



def names
  assignments.map do |assignment|
    if assignment.type?(:send, :indexasgn)
      assignment.method_name
    else
      assignment.name
    end
  end
end


  








  

    #rhs  
  



  

    


Alias for #expression.



  



  [ GitHub ]


  

  


# File 'lib/rubocop/ast/node/masgn_node.rb', line 42



alias rhs expression


  








  

    #values  ⇒ Array<Node> 
  



  

    


In contrast to #expression, values always returns a Ruby array
containing all the nodes being assigned on the RHS.






Literal arrays are considered a singular value; but unlike #expression,
implied array nodes from assigning multiple values on the RHS are treated
as separate.



  





  
Returns:


    
  
  • 
    (Array<Node>)
—    
    

    individual values being assigned on the RHS of the multiple assignment
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/rubocop/ast/node/masgn_node.rb', line 52



def values
  multiple_rhs? ? expression.children : [expression]
end