Class: Arachni::Platform::List

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/arachni/platform/list.rb

Overview

Represents a collection of applicable platforms.

Author:

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Enumerable

#realsize

Constructor Details

#initialize(valid_platforms) ⇒ List

Returns a new instance of List.

Parameters:

  • valid_platforms (Array<String, Symbol>) —

    Valid platforms for this list.



29
30
31
32
 
# File 'lib/arachni/platform/list.rb', line 29

def initialize( valid_platforms )
    @valid_platforms = normalize!( valid_platforms )
    @platforms       = []
end

Class Method Details

.normalize(platforms) ⇒ Object 



196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/arachni/platform/list.rb', line 196

def self.normalize( platforms )
    case platforms
        when self.class, Symbol
            platforms
        when String
            platforms.to_sym
        when Hash
            platforms.symbolize_keys
        when Enumerable, Array
            platforms.to_a.flatten.map( &:to_sym ).uniq.sort
    end
end

Instance Method Details

#<<(platform) ⇒ Platform

Returns ‘self`.

Parameters:

  • platform (Symbol, String) —

    Platform to add to the list.

Returns:

Raises:



128
129
130
131
 
# File 'lib/arachni/platform/list.rb', line 128

def <<( platform )
    @platforms |= [normalize( platform )]
    self
end

#any? ⇒ Boolean

Returns ‘true` if there are applicable platforms, `false` otherwise.

Returns:

  • (Boolean) —

    ‘true` if there are applicable platforms, `false` otherwise.



121
122
123
 
# File 'lib/arachni/platform/list.rb', line 121

def any?
    !empty?
end

#clear ⇒ Object

Clears platforms.



181
182
183
 
# File 'lib/arachni/platform/list.rb', line 181

def clear
    @platforms.clear
end

#dup ⇒ Platform

Returns Copy of ‘self`.

Returns:



186
187
188
 
# File 'lib/arachni/platform/list.rb', line 186

def dup
    self.class.new( @valid_platforms ).tap { |p| p.platforms = @platforms }
end

#each(&block) ⇒ Enumerator, Platform

Returns ‘Enumerator` if no `block` is given, `self` otherwise.

Parameters:

  • block (Block) —

    Block to be passed each platform.

Returns:

  • (Enumerator, Platform) —

    ‘Enumerator` if no `block` is given, `self` otherwise.



157
158
159
160
161
 
# File 'lib/arachni/platform/list.rb', line 157

def each( &block )
    return enum_for( __method__ ) if !block_given?
    @platforms.each( &block )
    self
end

#empty? ⇒ Boolean

Returns ‘true` if there are no applicable platforms, `false` otherwise.

Returns:

  • (Boolean) —

    ‘true` if there are no applicable platforms, `false` otherwise.



115
116
117
 
# File 'lib/arachni/platform/list.rb', line 115

def empty?
    @platforms.empty?
end

#hierarchical? ⇒ Boolean

Returns ‘true` if the list has a hierarchy, `false` otherwise.

Returns:

  • (Boolean) —

    ‘true` if the list has a hierarchy, `false` otherwise.



192
193
194
 
# File 'lib/arachni/platform/list.rb', line 192

def hierarchical?
    @valid_platforms.is_a? Hash
end

#include?(platform) ⇒ Boolean

Returns ‘true` if `platform` applies to the given resource, `false` otherwise.

Parameters:

  • platform (Symbol, String) —

    Platform to check.

Returns:

  • (Boolean) —

    ‘true` if `platform` applies to the given resource, `false` otherwise.

Raises:



167
168
169
 
# File 'lib/arachni/platform/list.rb', line 167

def include?( platform )
    @platforms.include? normalize( platform )
end

#include_any?(platforms) ⇒ Boolean

Returns ‘true` if any platform in `platforms` applies to the given resource, `false` otherwise.

Parameters:

  • platforms (Array<Symbol, String>) —

    Platform to check.

Returns:

  • (Boolean) —

    ‘true` if any platform in `platforms` applies to the given resource, `false` otherwise.

Raises:



176
177
178
 
# File 'lib/arachni/platform/list.rb', line 176

def include_any?( platforms )
    (@platforms & normalize( platforms )).any?
end

#invalid?(platforms) ⇒ Boolean

Returns ‘true` if platforms are invalid (i.e. not in #valid), `false` otherwise.

Parameters:

Returns:

  • (Boolean) —

    ‘true` if platforms are invalid (i.e. not in #valid), `false` otherwise.

See Also:



109
110
111
 
# File 'lib/arachni/platform/list.rb', line 109

def invalid?( platforms )
    !valid?( platforms )
end

#merge(enum) ⇒ Object Also known as: +, |

Parameters:

Raises:



138
139
140
 
# File 'lib/arachni/platform/list.rb', line 138

def merge( enum )
    dup.merge!( enum )
end

#merge!(enum) ⇒ Platform Also known as: update

Returns Updated ‘self`.

Parameters:

  • enum (Enumerable) —

    Enumerable object containing platforms.

Returns:

Raises:



148
149
150
151
 
# File 'lib/arachni/platform/list.rb', line 148

def merge!( enum )
    @platforms |= normalize( enum )
    self
end

#pick(data_per_platform) ⇒ Hash

Selects appropriate data depending on the applicable platforms from ‘data_per_platform`.

Parameters:

  • data_per_platform (Hash{<Symbol, String> => Object}) —

    Hash with platform names as keys and arbitrary data as values.

Returns:

  • (Hash) —

    ‘data_per_platform` with non-applicable entries removed.

Raises:



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/arachni/platform/list.rb', line 47

def pick( data_per_platform )
    orig_data_per_platform = data_per_platform.dup
    data_per_platform      = data_per_platform.dup

    data_per_platform.select! { |k, v| include? k }

    # Bail out if the valid platforms are just a flat array, without hierarchy.
    return data_per_platform if !hierarchical?

    # Keep track of parents which will be removed due to the existence of
    # their children.
    specified_parents = []

    # Remove parents if we have children.
    data_per_platform.keys.each do |platform|
        specified_parents |= parents = find_parents( platform )
        data_per_platform.reject! { |k, _| parents.include? k }
    end

    # Include all of the parents' children if parents are specified but no
    # children for them.

    children = {}
    children_for = valid & @platforms.to_a
    children_for.each do |platform|
        next if specified_parents.include? platform
        c = find_children( platform )
        children.merge! orig_data_per_platform.select { |k, _| c.include? k }
    end

    data_per_platform.merge! children

    # Include the nearest parent data there is a child platform but there
    # are no data for it.

    ignore = data_per_platform.keys | specified_parents
    orig_data_per_platform.each do |platform, data|
        next if ignore.include?( platform ) ||
            !include_any?( find_children( platform ) )
        data_per_platform[platform] = data
    end

    data_per_platform
end

#valid ⇒ Array<Symbol>

Returns Supported platforms.

Returns:

  • (Array<Symbol>) —

    Supported platforms.



35
36
37
 
# File 'lib/arachni/platform/list.rb', line 35

def valid
    hierarchical? ? @valid_platforms.find_symbol_keys_recursively : @valid_platforms
end

#valid?(platforms) ⇒ Boolean

Returns ‘true` if platforms are valid (i.e. in #valid), `false` otherwise.

Parameters:

Returns:

  • (Boolean) —

    ‘true` if platforms are valid (i.e. in #valid), `false` otherwise.

See Also:



97
98
99
100
101
102
 
# File 'lib/arachni/platform/list.rb', line 97

def valid?( platforms )
    normalize( platforms )
    true
rescue
    false
end