Class: Rubycop::Analyzer::Policy

Inherits:
Object
  • Object
show all
Defined in:
lib/rubycop/analyzer/policy.rb

Constant Summary collapse

CALL_BLACKLIST = 
%w[
  abort
  alias_method
  at_exit
  autoload
  binding
  callcc
  caller
  class_eval
  const_get
  const_set
  eval
  exec
  exit
  dup
  fail
  fork
  gets
  global_variables
  instance_eval
  load
  loop
  method
  module_eval
  open
  readline
  readlines
  redo
  remove_const
  retry
  require
  send
  set_trace_func
  sleep
  spawn
  srand
  syscall
  system
  trap
  undef
  __callee__
  __method__
].to_set.freeze
KEYWORD_WHITELIST = 
%w[
  false
  nil
  self
  true
].to_set.freeze

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Policy

Returns a new instance of Policy.



6
7
8
9
 
# File 'lib/rubycop/analyzer/policy.rb', line 6

def initialize
  @const_list = GrayList.new
  initialize_const_blacklist
end

Instance Method Details

#blacklist_const(const) ⇒ Object 



15
16
17
 
# File 'lib/rubycop/analyzer/policy.rb', line 15

def blacklist_const(const)
  @const_list.blacklist(const)
end

#const_allowed?(const) ⇒ Boolean

Returns:

  • (Boolean) 


19
20
21
 
# File 'lib/rubycop/analyzer/policy.rb', line 19

def const_allowed?(const)
  @const_list.allow?(const)
end

#inspect ⇒ Object 



11
12
13
 
# File 'lib/rubycop/analyzer/policy.rb', line 11

def inspect
  '#<%s:0x%x>' % [self.class.name, object_id]
end

#visit(node) ⇒ Object 



27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/rubycop/analyzer/policy.rb', line 27

def visit(node)
  klass = node.class.ancestors.detect do |ancestor|
    respond_to?("visit_#{ancestor.name.split('::').last}")
  end
  if klass
    send("visit_#{klass.name.split('::').last}", node)
  else
    warn "unhandled node type: #{node.inspect}:#{node.class.name}"
    true
  end
end

#visit_Alias(node) ⇒ Object 



39
40
41
 
# File 'lib/rubycop/analyzer/policy.rb', line 39

def visit_Alias(node)
  false # never allowed
end

#visit_Args(node) ⇒ Object 



43
44
45
 
# File 'lib/rubycop/analyzer/policy.rb', line 43

def visit_Args(node)
  node.elements.all? { |e| visit(e) }
end

#visit_Array(node) ⇒ Object 



47
48
49
 
# File 'lib/rubycop/analyzer/policy.rb', line 47

def visit_Array(node)
  node.elements.all? { |e| visit(e) }
end

#visit_Assoc(node) ⇒ Object 



51
52
53
 
# File 'lib/rubycop/analyzer/policy.rb', line 51

def visit_Assoc(node)
  visit(node.key) && visit(node.value)
end

#visit_Binary(node) ⇒ Object 



55
56
57
 
# File 'lib/rubycop/analyzer/policy.rb', line 55

def visit_Binary(node)
  visit(node.lvalue) && visit(node.rvalue)
end

#visit_Block(node) ⇒ Object 



59
60
61
 
# File 'lib/rubycop/analyzer/policy.rb', line 59

def visit_Block(node)
  (node.params.nil? || visit(node.params)) && node.elements.all? { |e| visit(e) }
end

#visit_Call(node) ⇒ Object 



107
108
109
 
# File 'lib/rubycop/analyzer/policy.rb', line 107

def visit_Call(node)
  !CALL_BLACKLIST.include?(node.identifier.token.to_s) && [node.target, node.arguments, node.block].compact.all? { |e| visit(e) }
end

#visit_Case(node) ⇒ Object 



111
112
113
 
# File 'lib/rubycop/analyzer/policy.rb', line 111

def visit_Case(node)
  visit(node.expression) && visit(node.block)
end

#visit_ChainedBlock(node) ⇒ Object 



115
116
117
 
# File 'lib/rubycop/analyzer/policy.rb', line 115

def visit_ChainedBlock(node)
  node.elements.all? { |e| visit(e) } && node.blocks.all? { |e| visit(e) } && (node.params.nil? || visit(node.params))
end

#visit_Char(node) ⇒ Object 



131
132
133
 
# File 'lib/rubycop/analyzer/policy.rb', line 131

def visit_Char(node)
  true
end

#visit_Class(node) ⇒ Object 



119
120
121
 
# File 'lib/rubycop/analyzer/policy.rb', line 119

def visit_Class(node)
  visit(node.const) && (node.superclass.nil? || visit(node.superclass)) && visit(node.body)
end

#visit_ClassVariable(node) ⇒ Object 



123
124
125
 
# File 'lib/rubycop/analyzer/policy.rb', line 123

def visit_ClassVariable(node)
  false # never allowed
end

#visit_ClassVariableAssignment(node) ⇒ Object 



127
128
129
 
# File 'lib/rubycop/analyzer/policy.rb', line 127

def visit_ClassVariableAssignment(node)
  false # never allowed
end

#visit_Constant(node) ⇒ Object 



135
136
137
 
# File 'lib/rubycop/analyzer/policy.rb', line 135

def visit_Constant(node)
  const_allowed?(node.token)
end

#visit_ConstantAssignment(node) ⇒ Object 



139
140
141
 
# File 'lib/rubycop/analyzer/policy.rb', line 139

def visit_ConstantAssignment(node)
  visit(node.lvalue) && visit(node.rvalue)
end

#visit_Defined(node) ⇒ Object 



143
144
145
 
# File 'lib/rubycop/analyzer/policy.rb', line 143

def visit_Defined(node)
  false # never allowed (though it's probably safe)
end

#visit_Else(node) ⇒ Object 



147
148
149
 
# File 'lib/rubycop/analyzer/policy.rb', line 147

def visit_Else(node)
  node.elements.all? { |e| visit(e) }
end

#visit_ExecutableString(node) ⇒ Object 



151
152
153
 
# File 'lib/rubycop/analyzer/policy.rb', line 151

def visit_ExecutableString(node)
  false # never allowed
end

#visit_Float(node) ⇒ Object 



155
156
157
 
# File 'lib/rubycop/analyzer/policy.rb', line 155

def visit_Float(node)
  true
end

#visit_For(node) ⇒ Object 



159
160
161
 
# File 'lib/rubycop/analyzer/policy.rb', line 159

def visit_For(node)
  visit(node.variable) && visit(node.range) && visit(node.statements)
end

#visit_GlobalVariable(node) ⇒ Object 



163
164
165
 
# File 'lib/rubycop/analyzer/policy.rb', line 163

def visit_GlobalVariable(node)
  false # never allowed
end

#visit_GlobalVariableAssignment(node) ⇒ Object 



167
168
169
 
# File 'lib/rubycop/analyzer/policy.rb', line 167

def visit_GlobalVariableAssignment(node)
  false # never allowed
end

#visit_Hash(node) ⇒ Object 



171
172
173
 
# File 'lib/rubycop/analyzer/policy.rb', line 171

def visit_Hash(node)
  node.assocs.nil? || node.assocs.all? { |e| visit(e) }
end

#visit_Identifier(node) ⇒ Object 



175
176
177
 
# File 'lib/rubycop/analyzer/policy.rb', line 175

def visit_Identifier(node)
  !CALL_BLACKLIST.include?(node.token)
end

#visit_If(node) ⇒ Object Also known as: visit_Unless 



179
180
181
 
# File 'lib/rubycop/analyzer/policy.rb', line 179

def visit_If(node)
  visit(node.expression) && node.elements.all? { |e| visit(e) } && node.blocks.all? { |e| visit(e) }
end

#visit_IfMod(node) ⇒ Object Also known as: visit_UnlessMod 



184
185
186
 
# File 'lib/rubycop/analyzer/policy.rb', line 184

def visit_IfMod(node)
  visit(node.expression) && node.elements.all? { |e| visit(e) }
end

#visit_IfOp(node) ⇒ Object 



189
190
191
 
# File 'lib/rubycop/analyzer/policy.rb', line 189

def visit_IfOp(node)
  visit(node.condition) && visit(node.then_part) && visit(node.else_part)
end

#visit_InstanceVariable(node) ⇒ Object 



193
194
195
 
# File 'lib/rubycop/analyzer/policy.rb', line 193

def visit_InstanceVariable(node)
  true
end

#visit_InstanceVariableAssignment(node) ⇒ Object 



197
198
199
 
# File 'lib/rubycop/analyzer/policy.rb', line 197

def visit_InstanceVariableAssignment(node)
  visit(node.rvalue)
end

#visit_Integer(node) ⇒ Object 



201
202
203
 
# File 'lib/rubycop/analyzer/policy.rb', line 201

def visit_Integer(node)
  true
end

#visit_Keyword(node) ⇒ Object 



212
213
214
 
# File 'lib/rubycop/analyzer/policy.rb', line 212

def visit_Keyword(node)
  KEYWORD_WHITELIST.include?(node.token)
end

#visit_Label(node) ⇒ Object 



216
217
218
 
# File 'lib/rubycop/analyzer/policy.rb', line 216

def visit_Label(node)
  true
end

#visit_LocalVariableAssignment(node) ⇒ Object 



220
221
222
 
# File 'lib/rubycop/analyzer/policy.rb', line 220

def visit_LocalVariableAssignment(node)
  visit(node.rvalue)
end

#visit_Method(node) ⇒ Object 



224
225
226
 
# File 'lib/rubycop/analyzer/policy.rb', line 224

def visit_Method(node)
  [node.target, node.params, node.body].compact.all? { |e| visit(e) }
end

#visit_Module(node) ⇒ Object 



228
229
230
 
# File 'lib/rubycop/analyzer/policy.rb', line 228

def visit_Module(node)
  visit(node.const) && visit(node.body)
end

#visit_MultiAssignment(node) ⇒ Object 



232
233
234
 
# File 'lib/rubycop/analyzer/policy.rb', line 232

def visit_MultiAssignment(node)
  visit(node.lvalue) && visit(node.rvalue)
end

#visit_MultiAssignmentList(node) ⇒ Object 



236
237
238
 
# File 'lib/rubycop/analyzer/policy.rb', line 236

def visit_MultiAssignmentList(node)
  node.elements.all? { |e| visit(e) }
end

#visit_Params(node) ⇒ Object 



240
241
242
 
# File 'lib/rubycop/analyzer/policy.rb', line 240

def visit_Params(node)
  node.elements.all? { |e| visit(e) }
end

#visit_Program(node) ⇒ Object 



244
245
246
 
# File 'lib/rubycop/analyzer/policy.rb', line 244

def visit_Program(node)
  node.elements.all? { |e| visit(e) }
end

#visit_Range(node) ⇒ Object 



248
249
250
 
# File 'lib/rubycop/analyzer/policy.rb', line 248

def visit_Range(node)
  visit(node.min) && visit(node.max)
end

#visit_RescueMod(node) ⇒ Object 



252
253
254
 
# File 'lib/rubycop/analyzer/policy.rb', line 252

def visit_RescueMod(node)
  node.elements.all? { |e| visit(e) } && visit(node.expression)
end

#visit_RescueParams(node) ⇒ Object 



256
257
258
 
# File 'lib/rubycop/analyzer/policy.rb', line 256

def visit_RescueParams(node)
  node.elements.all? { |e| visit(e) }
end

#visit_SingletonClass(node) ⇒ Object 



260
261
262
 
# File 'lib/rubycop/analyzer/policy.rb', line 260

def visit_SingletonClass(node)
  visit(node.superclass) && visit(node.body)
end

#visit_SplatArg(node) ⇒ Object 



264
265
266
 
# File 'lib/rubycop/analyzer/policy.rb', line 264

def visit_SplatArg(node)
  visit(node.arg)
end

#visit_Statements(node) ⇒ Object 



268
269
270
 
# File 'lib/rubycop/analyzer/policy.rb', line 268

def visit_Statements(node)
  node.elements.all? { |e| visit(e) }
end

#visit_String(node) ⇒ Object 



272
273
274
275
 
# File 'lib/rubycop/analyzer/policy.rb', line 272

def visit_String(node)
  # embedded strings can have statements in them, so check those
  node.elements.reject { |e| e.is_a?(::String) }.all? { |e| visit(e) }
end

#visit_StringConcat(node) ⇒ Object 



277
278
279
 
# File 'lib/rubycop/analyzer/policy.rb', line 277

def visit_StringConcat(node)
  node.elements.all? { |e| visit(e) }
end

#visit_Symbol(node) ⇒ Object 



281
282
283
 
# File 'lib/rubycop/analyzer/policy.rb', line 281

def visit_Symbol(node)
  true
end

#visit_Unary(node) ⇒ Object 



285
286
287
 
# File 'lib/rubycop/analyzer/policy.rb', line 285

def visit_Unary(node)
  visit(node.operand)
end

#visit_Until(node) ⇒ Object Also known as: visit_UntilMod 



289
290
291
 
# File 'lib/rubycop/analyzer/policy.rb', line 289

def visit_Until(node)
  false # never allowed
end

#visit_When(node) ⇒ Object 



294
295
296
 
# File 'lib/rubycop/analyzer/policy.rb', line 294

def visit_When(node)
  visit(node.expression) && node.elements.all? { |e| visit(e) }
end

#visit_While(node) ⇒ Object Also known as: visit_WhileMod 



298
299
300
 
# File 'lib/rubycop/analyzer/policy.rb', line 298

def visit_While(node)
  false # never allowed
end

#whitelist_const(const) ⇒ Object 



23
24
25
 
# File 'lib/rubycop/analyzer/policy.rb', line 23

def whitelist_const(const)
  @const_list.whitelist(const)
end