Module: RuboCop::Cop::Util

Includes:
PathUtil
Included in:
Cop, LineBreakCorrector, PercentLiteralCorrector, StringLiteralCorrector
Defined in:
lib/rubocop/cop/util.rb

Overview

This module contains a collection of useful utility methods.

Constant Summary collapse

LITERAL_REGEX =

Match literal regex characters, not including anchors, character classes, alternatives, groups, repetitions, references, etc

%r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze

Class Method Summary collapse

Methods included from PathUtil

absolute?, chdir, hidden_dir?, hidden_file_in_not_hidden_dir?, match_path?, pwd, relative_path, reset_pwd, smart_path

Class Method Details

.add_parentheses(node, corrector) ⇒ Object 



33
34
35
36
37
38
39
40
 
# File 'lib/rubocop/cop/util.rb', line 33

def add_parentheses(node, corrector)
  if node.arguments.empty?
    corrector.insert_after(node, '()')
  else
    corrector.replace(args_begin(node), '(')
    corrector.insert_after(args_end(node), ')')
  end
end

.args_begin(node) ⇒ Object 



42
43
44
45
46
47
 
# File 'lib/rubocop/cop/util.rb', line 42

def args_begin(node)
  loc = node.loc
  selector =
    node.super_type? || node.yield_type? ? loc.keyword : loc.selector
  selector.end.resize(1)
end

.args_end(node) ⇒ Object 



49
50
51
 
# File 'lib/rubocop/cop/util.rb', line 49

def args_end(node)
  node.loc.expression.end
end

.begins_its_line?(range) ⇒ Boolean

Returns:

  • (Boolean) 


62
63
64
 
# File 'lib/rubocop/cop/util.rb', line 62

def begins_its_line?(range)
  (range.source_line =~ /\S/) == range.column
end

.comment_line?(line_source) ⇒ Boolean

Returns:

  • (Boolean) 


16
17
18
 
# File 'lib/rubocop/cop/util.rb', line 16

def comment_line?(line_source)
  line_source =~ /^\s*#/
end

.comment_lines?(node) ⇒ Boolean

Returns:

  • (Boolean) 


20
21
22
 
# File 'lib/rubocop/cop/util.rb', line 20

def comment_lines?(node)
  processed_source[line_range(node)].any? { |line| comment_line?(line) }
end

.double_quotes_required?(string) ⇒ Boolean

If converting a string to Ruby string literal source code, must double quotes be used?

Returns:

  • (Boolean) 


84
85
86
87
88
89
90
91
92
 
# File 'lib/rubocop/cop/util.rb', line 84

def double_quotes_required?(string)
  # Double quotes are required for strings which either:
  # - Contain single quotes
  # - Contain non-printable characters, which must use an escape

  # Regex matches IF there is a ' or there is a \\ in the string that is
  # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
  string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
end

.escape_string(string) ⇒ Object 



98
99
100
 
# File 'lib/rubocop/cop/util.rb', line 98

def escape_string(string)
  string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
end

.first_part_of_call_chain(node) ⇒ Object

Returns, for example, a bare ‘if` node if the given node is an `if` with calls chained to the end of it.



68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/rubocop/cop/util.rb', line 68

def first_part_of_call_chain(node)
  while node
    case node.type
    when :send
      node = node.receiver
    when :block
      node = node.send_node
    else
      break
    end
  end
  node
end

.interpret_string_escapes(string) ⇒ Object 



114
115
116
 
# File 'lib/rubocop/cop/util.rb', line 114

def interpret_string_escapes(string)
  StringInterpreter.interpret(string)
end

.line_range(node) ⇒ Object 



24
25
26
 
# File 'lib/rubocop/cop/util.rb', line 24

def line_range(node)
  node.first_line..node.last_line
end

.needs_escaping?(string) ⇒ Boolean

Returns:

  • (Boolean) 


94
95
96
 
# File 'lib/rubocop/cop/util.rb', line 94

def needs_escaping?(string)
  double_quotes_required?(escape_string(string))
end

.on_node(syms, sexp, excludes = []) {|sexp| ... } ⇒ Object

Yields:

  • (sexp) 


53
54
55
56
57
58
59
60
 
# File 'lib/rubocop/cop/util.rb', line 53

def on_node(syms, sexp, excludes = [], &block)
  return to_enum(:on_node, syms, sexp, excludes) unless block_given?

  yield sexp if Array(syms).include?(sexp.type)
  return if Array(excludes).include?(sexp.type)

  sexp.each_child_node { |elem| on_node(syms, elem, excludes, &block) }
end

.parentheses?(node) ⇒ Boolean

Returns:

  • (Boolean) 


28
29
30
31
 
# File 'lib/rubocop/cop/util.rb', line 28

def parentheses?(node)
  node.loc.respond_to?(:end) && node.loc.end &&
    node.loc.end.is?(')')
end

.same_line?(node1, node2) ⇒ Boolean

Returns:

  • (Boolean) 


118
119
120
121
122
 
# File 'lib/rubocop/cop/util.rb', line 118

def same_line?(node1, node2)
  node1.respond_to?(:loc) &&
    node2.respond_to?(:loc) &&
    node1.loc.line == node2.loc.line
end

.to_string_literal(string) ⇒ Object 



102
103
104
105
106
107
108
 
# File 'lib/rubocop/cop/util.rb', line 102

def to_string_literal(string)
  if needs_escaping?(string) && compatible_external_encoding_for?(string)
    string.inspect
  else
    "'#{string.gsub('\\') { '\\\\' }}'"
  end
end

.to_supported_styles(enforced_style) ⇒ Object 



124
125
126
127
128
 
# File 'lib/rubocop/cop/util.rb', line 124

def to_supported_styles(enforced_style)
  enforced_style
    .sub(/^Enforced/, 'Supported')
    .sub('Style', 'Styles')
end

.tokens(node) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/rubocop/cop/util.rb', line 130

def tokens(node)
  @tokens ||= {}
  return @tokens[node.object_id] if @tokens[node.object_id]

  source_range = node.source_range
  begin_pos = source_range.begin_pos
  end_pos = source_range.end_pos

  @tokens[node.object_id] = processed_source.tokens.select do |token|
    token.end_pos <= end_pos && token.begin_pos >= begin_pos
  end
end

.trim_string_interporation_escape_character(str) ⇒ Object 



110
111
112
 
# File 'lib/rubocop/cop/util.rb', line 110

def trim_string_interporation_escape_character(str)
  str.gsub(/\\\#{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
end