module Ameba::AST::Util

Overview

Utility module for Ameba's rules.

Extended Modules

Direct including types

Defined in:

ameba/ast/util.cr

Instance Method Summary

Instance Method Detail

def abort?(node) #

Returns true if node represents abort method call.


def control_exp_code(node : Crystal::ControlExpression, code_lines) #

Returns the exp code of a control expression. Wraps implicit tuple literal with curly brackets (e.g. multi-return).


def dynamic_literal?(node) : Bool #

Returns true if current node is a dynamic literal, false otherwise.


def each_inline_directive(source, &block : Crystal::Token, String, Array(String) -> _) #

Yields each inline directive found in the source.


def exit?(node) #

Returns true if node represents exit method call.


def flow_command?(node, in_loop) #

Returns true if node is a flow command, false otherwise. Node represents a flow command if it is a control expression, or special call node that interrupts execution (i.e. raise, exit, abort).


def flow_expression?(node, in_loop = false) #

Returns true if node is a flow expression, false if not. Node represents a flow expression if it is full-filled by a flow command.

For example, this node is a flow expression, because each branch contains a flow command return:

if a > 0
  return :positive
elsif a < 0
  return :negative
else
  return :zero
end

This node is a not a flow expression:

if a > 0
  return :positive
end

That's because not all branches return(i.e. else is missing).


def has_arguments?(node) : Bool #

Returns true if the node is a Crystal::Call with either node.block or node.block_arg set, false otherwise.


def has_block?(node) : Bool #

Returns true if the node is a Crystal::Call with either node.block or node.block_arg set, false otherwise.


def has_short_block?(node, code_lines) #

Returns true if node is a call with a short block version (&.foo?).


def heredoc?(node : Crystal::ASTNode, source : Source) #

Returns true if node is a heredoc, false otherwise.


def literal?(node) : Bool #

Returns true if current node is a literal, false otherwise.


def loop?(node) #

Returns true if node represents a loop.


def name_end_location(node) #

Returns nil if node does not contain a name.

NOTE Use this instead of Crystal::Call#name_end_location to avoid an off-by-one error.


def name_location(node) #

Returns nil if node does not contain a name.


def name_location_or(token : Crystal::Token, name, *, adjust_location_column_number = nil) #

def name_location_or(node : Crystal::ASTNode, *, adjust_location_column_number = nil) #

def name_size(node) #

Returns zero if node does not contain a name.


def node_source(node, code_lines) #

Returns a source code for the current node. This method uses node.location and node.end_location to determine and cut a piece of source of the node.


def nodoc?(node) #

Returns true if node has a :nodoc: annotation as the first line.


def operator_method?(node) #

Returns true if node represents operator method.


def operator_method_name?(name : String) #

Returns true if name represents operator method.


def path_name(node : Crystal::Path, *, include_global = true) : String #

Returns the path name of the path.

If include_global is true (default), the global prefix :: is included.


def path_named?(node, *names : String) : Bool #

Returns true if current node is a Crystal::Path matching given name, false otherwise.


def raise?(node) #

Returns true if node represents raise method call.


def setter_method?(node) #

Returns true if node represents setter method.


def setter_method_name?(name : String) #

Returns true if name represents setter method.


def short_block?(node, code_lines) #

Returns true if node represents a short block version (&.foo?).


def source_between(loc, end_loc, code_lines) : String | Nil #

Returns the source code from loc to end_loc (inclusive).


def static_literal?(node) : Bool #

Returns true if current node is a static literal, false otherwise.


def suffix?(node) #

Returns true if node is a suffix node (if / unless / rescue / ensure).


def takes_arguments?(node) : Bool #

Returns true if the node is a Crystal::Def with either args, splat_index, or double_splat set, false otherwise.