Module: Watobo::Findings

Defined in:
lib/watobo/core/findings.rb

Overview

:nodoc: all

Class Method Summary collapse

Class Method Details

.add(finding, opts = {}) ⇒ Object 



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/watobo/core/findings.rb', line 85

def self.add(finding, opts={})
  @findings_lock.synchronize do
    options = {
      :notify => true,
      :save_finding => true
    }
    options.update opts
    puts "[Project] add finding #{finding.fid}" if $DEBUG


    # only add finding if it (its fid) doesn't already exist
    unless @findings.has_key?(finding.fid)
      begin
        @findings[finding.fid] = finding
        notify(:new, finding) if options[:notify] == true

        Watobo::DataStore.add_finding(finding) if options[:save_finding] == true
      rescue => bang
        puts "!!!ERROR: #{Module.nesting[0].name}"
        puts bang
        puts bang.backtrace if $DEBUG
      end
    end
  end

end

.clearEvents(event) ⇒ Object 



11
12
13
14
 
# File 'lib/watobo/core/findings.rb', line 11

def self.clearEvents(event)
  @event_dispatcher_listeners[event] ||= []
  @event_dispatcher_listeners[event].clear
end

.delete(finding) ⇒ Object 



78
79
80
81
82
83
 
# File 'lib/watobo/core/findings.rb', line 78

def self.delete(finding)
  @findings_lock.synchronize do
    Watobo::DataStore.delete_finding(finding)
    @findings.delete finding.fid        
  end
end

.each(&block) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/watobo/core/findings.rb', line 70

def self.each(&block)
  if block_given?
    @findings_lock.synchronize do
      @findings.map{|f| yield f }
    end
  end
end

.exist?(finding) ⇒ Boolean

Returns:

  • (Boolean) 


33
34
35
 
# File 'lib/watobo/core/findings.rb', line 33

def self.exist?(finding)
  @findings.has_key?(finding.details[:fid])
end

.length ⇒ Object 



24
25
26
 
# File 'lib/watobo/core/findings.rb', line 24

def self.length
  @findings.length
end

.notify(event, *args) ⇒ Object 



16
17
18
19
20
21
22
 
# File 'lib/watobo/core/findings.rb', line 16

def self.notify(event, *args)
  if @event_dispatcher_listeners[event]
    @event_dispatcher_listeners[event].each do |m|
      m.call(*args) if m.respond_to? :call
    end
  end
end

.reset ⇒ Object 



28
29
30
31
 
# File 'lib/watobo/core/findings.rb', line 28

def self.reset
  @findings = {}
  @event_dispatcher_listeners = Hash.new
end

.set(finding, prefs) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
 
# File 'lib/watobo/core/findings.rb', line 37

def self.set(finding, prefs)
  @findings_lock.synchronize do
    if @findings.has_key? finding.fid
      @findings[finding.fid].details.update prefs
      Watobo::DataStore.update_finding(finding)
    return true
    end
    return false
  end
end

.set_false_positive(finding) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
 
# File 'lib/watobo/core/findings.rb', line 59

def self.set_false_positive(finding)
  @findings_lock.synchronize do
    if @findings.has_key? finding.fid
      @findings[finding.fid].set_false_positive
      Watobo::DataStore.update_finding(finding)
    return true
    end
    return false
  end
end

.subscribe(event, &callback) ⇒ Object 



7
8
9
 
# File 'lib/watobo/core/findings.rb', line 7

def self.subscribe(event, &callback)
  (@event_dispatcher_listeners[event] ||= []) << callback
end

.unset_false_positive(finding) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
 
# File 'lib/watobo/core/findings.rb', line 48

def self.unset_false_positive(finding)
  @findings_lock.synchronize do
    if @findings.has_key? finding.fid
      @findings[finding.fid].unset_false_positive
      Watobo::DataStore.update_finding(finding)
    return true
    end
    return false
  end
end