Class: Spoom::Deadcode::Plugins::Base Abstract

Inherits:
Object
  • Object
show all
Defined in:
lib/spoom/deadcode/plugins/base.rb

Overview

This class is abstract.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(index) ⇒ Base

: (Index index) -> void



126
127
128
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 126

def initialize(index)
  @index = index
end

Instance Attribute Details

#index ⇒ Object (readonly)

: Index



123
124
125
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 123

def index
  @index
end

Class Method Details

.ignore_classes_inheriting_from(*names) ⇒ Object

Mark classes directly subclassing a class matching ‘names` as ignored.

Names can be either strings or regexps:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

ignore_classes_inheriting_from(
  "Foo",
  "Bar",
  /Baz.*/,
)

end ~~~ : (*(String | Regexp) names) -> void



46
47
48
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 46

def ignore_classes_inheriting_from(*names)
  save_names_and_patterns(names, :@ignored_subclasses_of_names, :@ignored_subclasses_of_patterns)
end

.ignore_classes_named(*names) ⇒ Object

Mark classes matching ‘names` as ignored.

Names can be either strings or regexps:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

ignore_class_names(
  "Foo",
  "Bar",
  /Baz.*/,
)

end ~~~ : (*(String | Regexp) names) -> void



28
29
30
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 28

def ignore_classes_named(*names)
  save_names_and_patterns(names, :@ignored_class_names, :@ignored_class_patterns)
end

.ignore_constants_named(*names) ⇒ Object

Mark constants matching ‘names` as ignored.

Names can be either strings or regexps:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

ignore_class_names(
  "FOO",
  "BAR",
  /BAZ.*/,
)

end ~~~ : (*(String | Regexp) names) -> void



64
65
66
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 64

def ignore_constants_named(*names)
  save_names_and_patterns(names, :@ignored_constant_names, :@ignored_constant_patterns)
end

.ignore_methods_named(*names) ⇒ Object

Mark methods matching ‘names` as ignored.

Names can be either strings or regexps:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

ignore_method_names(
  "foo",
  "bar",
  /baz.*/,
)

end ~~~ : (*(String | Regexp) names) -> void



82
83
84
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 82

def ignore_methods_named(*names)
  save_names_and_patterns(names, :@ignored_method_names, :@ignored_method_patterns)
end

.ignore_modules_named(*names) ⇒ Object

Mark modules matching ‘names` as ignored.

Names can be either strings or regexps:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

ignore_class_names(
  "Foo",
  "Bar",
  /Baz.*/,
)

end ~~~ : (*(String | Regexp) names) -> void



100
101
102
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 100

def ignore_modules_named(*names)
  save_names_and_patterns(names, :@ignored_module_names, :@ignored_module_patterns)
end

Instance Method Details

#internal_on_define_accessor(definition) ⇒ Object

Do not override this method, use ‘on_define_accessor` instead. : (Model::Attr definition) -> void



152
153
154
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 152

def internal_on_define_accessor(definition)
  on_define_accessor(definition)
end

#internal_on_define_class(definition) ⇒ Object

Do not override this method, use ‘on_define_class` instead. : (Model::Class definition) -> void



176
177
178
179
180
181
182
183
184
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 176

def internal_on_define_class(definition)
  if ignored_class_name?(definition.name)
    @index.ignore(definition)
  elsif ignored_subclass?(definition)
    @index.ignore(definition)
  end

  on_define_class(definition)
end

#internal_on_define_constant(definition) ⇒ Object

Do not override this method, use ‘on_define_constant` instead. : (Model::Constant definition) -> void



206
207
208
209
210
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 206

def internal_on_define_constant(definition)
  @index.ignore(definition) if ignored_constant_name?(definition.name)

  on_define_constant(definition)
end

#internal_on_define_method(definition) ⇒ Object

Do not override this method, use ‘on_define_method` instead. : (Model::Method definition) -> void



232
233
234
235
236
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 232

def internal_on_define_method(definition)
  @index.ignore(definition) if ignored_method_name?(definition.name)

  on_define_method(definition)
end

#internal_on_define_module(definition) ⇒ Object

Do not override this method, use ‘on_define_module` instead. : (Model::Module definition) -> void



258
259
260
261
262
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 258

def internal_on_define_module(definition)
  @index.ignore(definition) if ignored_module_name?(definition.name)

  on_define_module(definition)
end

#on_define_accessor(definition) ⇒ Object

Called when an accessor is defined.

Will be called when the indexer processes a ‘attr_reader`, `attr_writer` or `attr_accessor` node. Note that when this method is called, the definition for the node has already been added to the index. It is still possible to ignore it from the plugin:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

def on_define_accessor(definition)
  @index.ignore(definition) if symbol_def.name == "foo"
end

end ~~~ : (Model::Attr definition) -> void



146
147
148
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 146

def on_define_accessor(definition)
  # no-op
end

#on_define_class(definition) ⇒ Object

Called when a class is defined.

Will be called when the indexer processes a ‘class` node. Note that when this method is called, the definition for the node has already been added to the index. It is still possible to ignore it from the plugin:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

def on_define_class(definition)
  @index.ignore(definition) if definition.name == "Foo"
end

end ~~~ : (Model::Class definition) -> void



170
171
172
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 170

def on_define_class(definition)
  # no-op
end

#on_define_constant(definition) ⇒ Object

Called when a constant is defined.

Will be called when the indexer processes a ‘CONST =` node. Note that when this method is called, the definition for the node has already been added to the index. It is still possible to ignore it from the plugin:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

def on_define_constant(definition)
  @index.ignore(definition) if definition.name == "FOO"
end

end ~~~ : (Model::Constant definition) -> void



200
201
202
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 200

def on_define_constant(definition)
  # no-op
end

#on_define_method(definition) ⇒ Object

Called when a method is defined.

Will be called when the indexer processes a ‘def` or `defs` node. Note that when this method is called, the definition for the node has already been added to the index. It is still possible to ignore it from the plugin:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

def on_define_method(definition)
  @index.ignore(definition) if definition.name == "foo"
end

end ~~~ : (Model::Method definition) -> void



226
227
228
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 226

def on_define_method(definition)
  # no-op
end

#on_define_module(definition) ⇒ Object

Called when a module is defined.

Will be called when the indexer processes a ‘module` node. Note that when this method is called, the definition for the node has already been added to the index. It is still possible to ignore it from the plugin:

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

def on_define_module(definition)
  @index.ignore(definition) if definition.name == "Foo"
end

end ~~~ : (Model::Module definition) -> void



252
253
254
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 252

def on_define_module(definition)
  # no-op
end

#on_send(send) ⇒ Object

Called when a send is being processed

~~~rb class MyPlugin < Spoom::Deadcode::Plugins::Base

def on_send(send)
  return unless send.name == "dsl_method"
  return if send.args.empty?

  method_name = send.args.first.slice.delete_prefix(":")
  @index.reference_method(method_name, send.node, send.loc)
end

end ~~~ : (Send send) -> void



278
279
280
 
# File 'lib/spoom/deadcode/plugins/base.rb', line 278

def on_send(send)
  # no-op
end