Class: Marshalsea::Scanner

Inherits:

Object

• Object
• Marshalsea::Scanner

Defined in:

lib/marshalsea/scanner.rb

Defined Under Namespace

Classes: Candidate, Report, Suppression

Constant Summary

GATE_GATED =

:gated

GATE_SOFT =

:soft

GATE_UNGATED =

:ungated

GATE_LINK =

:link

FORMAT_MARSHAL =

:marshal

FORMAT_PSYCH =

:psych

VARIADIC =

-1

ENTRY_POINTS =

{
  "marshal_load" => { gate: GATE_GATED, arity: 1, formats: [FORMAT_MARSHAL, FORMAT_PSYCH] },
  "_load_data" => { gate: GATE_GATED, arity: 1, formats: [FORMAT_MARSHAL] },
  "_load" => { gate: GATE_GATED, arity: 1, formats: [FORMAT_MARSHAL], singleton: true },
  "init_with" => { gate: GATE_SOFT, arity: 1, formats: [FORMAT_PSYCH] },
  "hash" => { gate: GATE_UNGATED, arity: 0, formats: [FORMAT_MARSHAL, FORMAT_PSYCH] },
  "eql?" => { gate: GATE_UNGATED, arity: 1, formats: [FORMAT_MARSHAL, FORMAT_PSYCH] },
  "<=>" => { gate: GATE_UNGATED, arity: 1, formats: [FORMAT_MARSHAL] },
  "==" => { gate: GATE_UNGATED, arity: 1, formats: [FORMAT_PSYCH] },
  "[]=" => { gate: GATE_UNGATED, arity: 2, formats: [FORMAT_PSYCH] },
  "method_missing" => { gate: GATE_UNGATED, arity: VARIADIC, formats: [FORMAT_MARSHAL, FORMAT_PSYCH] },
  "respond_to_missing?" => { gate: GATE_UNGATED, arity: 2, formats: [FORMAT_MARSHAL, FORMAT_PSYCH] },
  "respond_to?" => { gate: GATE_UNGATED, arity: VARIADIC, formats: [FORMAT_PSYCH] },
  "to_s" => { gate: GATE_LINK, arity: 0, formats: [] },
  "coerce" => { gate: GATE_LINK, arity: 1, formats: [] }
}.freeze

GATED_METHODS =

ENTRY_POINTS.select { |_, spec| spec[:gate] == GATE_GATED && !spec[:singleton] }
.keys.freeze

GATED_SINGLETON_METHODS =

ENTRY_POINTS.select { |_, spec| spec[:singleton] }.keys.freeze

UNGATED_METHODS =

ENTRY_POINTS.select { |_, spec| spec[:gate] == GATE_UNGATED }.keys.freeze

LINK_METHODS =

ENTRY_POINTS.select { |_, spec| spec[:gate] == GATE_LINK }.keys.freeze

INSTANCE_METHODS =

ENTRY_POINTS.reject { |_, spec| spec[:singleton] }.keys.freeze

SINGLETON_METHODS =

GATED_SINGLETON_METHODS

PRISM_AVAILABLE =

begin
  require "prism"
  true
rescue LoadError
  false
end

LOCATION_SEPARATOR =

":"

UNKNOWN_LOCATION =

nil

STATE_UNREADABLE =

:unreadable

STATE_UNANALYSABLE =

:unanalysable

STATE_VERDICTS =

[true, false].freeze

SITE_MODULE_NAME =

:module_name

SITE_OWN_METHODS =

:own_methods

SITE_CANDIDATE =

:candidate

SITE_SOURCE_PARSE =

:source_parse

SITE_STATE_ANALYSIS =

:state_analysis

SITES =

[SITE_MODULE_NAME, SITE_OWN_METHODS, SITE_CANDIDATE,
SITE_SOURCE_PARSE, SITE_STATE_ANALYSIS].freeze

LOSSY_SITES =

[SITE_MODULE_NAME, SITE_OWN_METHODS, SITE_CANDIDATE].freeze

SUBJECT_UNNAMED =

"(module that cannot report a name)"

Instance Method Summary

• #initialize(namespace: nil) ⇒ Scanner constructor

  A new instance of Scanner.

• #scan ⇒ Object

Constructor Details

#initialize(namespace: nil) ⇒ Scanner

Returns a new instance of Scanner.

# File 'lib/marshalsea/scanner.rb', line 237

def initialize(namespace: nil)
  @namespace = namespace
  @candidates = []
  @definition_cache = {}
  @scanned_modules = 0
  @suppressions = []
end

Instance Method Details

#scan ⇒ Object

# File 'lib/marshalsea/scanner.rb', line 245

def scan
  each_named_module do |mod, name|
    @scanned_modules += 1
    collect_instance_methods(mod, name)
    collect_singleton_methods(mod, name)
  end

  Report.new(@candidates.sort_by(&:to_s), @scanned_modules, @suppressions.freeze)
end