Class: RuboCop::AST::Builder

Inherits:
Parser::Builders::Default
  • Object
show all
Defined in:
lib/rubocop/ast/builder.rb

Overview

‘RuboCop::AST::Builder` is an AST builder that is utilized to let `Parser` generate ASTs with Node.

Examples:

buffer = Parser::Source::Buffer.new('(string)')
buffer.source = 'puts :foo'

builder = RuboCop::AST::Builder.new
require 'parser/ruby25'
parser = Parser::Ruby25.new(builder)
root_node = parser.parse(buffer)

Constant Summary collapse

NODE_MAP =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

{
  and:                 AndNode,
  and_asgn:            AndAsgnNode,
  alias:               AliasNode,
  arg:                 ArgNode,
  blockarg:            ArgNode,
  forward_arg:         ArgNode,
  kwarg:               ArgNode,
  kwoptarg:            ArgNode,
  kwrestarg:           ArgNode,
  optarg:              ArgNode,
  restarg:             ArgNode,
  shadowarg:           ArgNode,
  args:                ArgsNode,
  array:               ArrayNode,
  lvasgn:              AsgnNode,
  ivasgn:              AsgnNode,
  cvasgn:              AsgnNode,
  gvasgn:              AsgnNode,
  block:               BlockNode,
  numblock:            BlockNode,
  break:               BreakNode,
  case_match:          CaseMatchNode,
  casgn:               CasgnNode,
  case:                CaseNode,
  class:               ClassNode,
  const:               ConstNode,
  def:                 DefNode,
  defined?:            DefinedNode,
  defs:                DefNode,
  dstr:                DstrNode,
  ensure:              EnsureNode,
  for:                 ForNode,
  forward_args:        ForwardArgsNode,
  forwarded_kwrestarg: KeywordSplatNode,
  float:               FloatNode,
  hash:                HashNode,
  if:                  IfNode,
  in_pattern:          InPatternNode,
  int:                 IntNode,
  index:               IndexNode,
  indexasgn:           IndexasgnNode,
  irange:              RangeNode,
  erange:              RangeNode,
  kwargs:              HashNode,
  kwbegin:             KeywordBeginNode,
  kwsplat:             KeywordSplatNode,
  lambda:              LambdaNode,
  masgn:               MasgnNode,
  mlhs:                MlhsNode,
  module:              ModuleNode,
  next:                NextNode,
  op_asgn:             OpAsgnNode,
  or_asgn:             OrAsgnNode,
  or:                  OrNode,
  pair:                PairNode,
  procarg0:            Procarg0Node,
  rational:            RationalNode,
  regexp:              RegexpNode,
  rescue:              RescueNode,
  resbody:             ResbodyNode,
  return:              ReturnNode,
  csend:               CsendNode,
  send:                SendNode,
  str:                 StrNode,
  xstr:                StrNode,
  sclass:              SelfClassNode,
  super:               SuperNode,
  zsuper:              SuperNode,
  sym:                 SymbolNode,
  until:               UntilNode,
  until_post:          UntilNode,
  lvar:                VarNode,
  ivar:                VarNode,
  cvar:                VarNode,
  gvar:                VarNode,
  when:                WhenNode,
  while:               WhileNode,
  while_post:          WhileNode,
  yield:               YieldNode
}.freeze

Instance Method Summary collapse

Instance Method Details

#n(type, children, source_map) ⇒ Node

Generates Node from the given information.

Returns:

  • (Node) —

    the generated node



106
107
108
 
# File 'lib/rubocop/ast/builder.rb', line 106

def n(type, children, source_map)
  node_klass(type).new(type, children, location: source_map)
end

#string_value(token) ⇒ Object

TODO: Figure out what to do about literal encoding handling… More details here github.com/whitequark/parser/issues/283



112
113
114
 
# File 'lib/rubocop/ast/builder.rb', line 112

def string_value(token)
  value(token)
end