Class: Set

9
10
11
12
13
14
15
16
17
18
19
20

# File 'opal/stdlib/set.rb', line 9
def initialize(enum = nil, &block)
 @hash = {}
 return if enum.nil?
 raise ArgumentError, 'value must be enumerable' unless Enumerable  === enum
 if block
 enum.each { |item| add yield(item) }
 else
 merge(enum)
 end
end

5
6
7

# File 'opal/stdlib/set.rb', line 5
def self.[](*ary)
 new(ary)
end

27
28
29
30
31
32
33

# File 'opal/stdlib/set.rb', line 27
def -(enum)
 unless enum.respond_to? :each
 raise ArgumentError, 'value must be enumerable'
 end
 dup.subtract(enum)
end

40
41
42
43
44
45
46
47
48
49
50

# File 'opal/stdlib/set.rb', line 40
def ==(other)
 if equal?(other)
 true
 elsif other.instance_of?(self.class)
 @hash == other.instance_variable_get(:@hash)
 elsif other.is_a?(Set ) && size == other.size
 other.all? { |o| @hash.include?(o) }
 else
 false
 end
end

52
53
54
55

# File 'opal/stdlib/set.rb', line 52
def add(o)
 @hash[o] = true
 self
end

96
97
98
99
100
101
102

# File 'opal/stdlib/set.rb', line 96
def add?(o)
 if include?(o)
 nil
 else
 add(o)
 end
end

58
59
60
61
62
63
64
65
66

# File 'opal/stdlib/set.rb', line 58
def classify(&block)
 return enum_for(:classify) unless block_given?
 result = Hash .new  { |h, k| h[k] = self.class.new }
 each { |item| result[yield(item)].add item }
 result
end

118
119
120
121

# File 'opal/stdlib/set.rb', line 118
def clear
 @hash.clear
 self
end

68
69
70
71
72
73

# File 'opal/stdlib/set.rb', line 68
def collect!(&block)
 return enum_for(:collect!) unless block_given?
 result = self.class.new
 each { |item| result << yield(item) }
 replace result
end

76
77
78
79

# File 'opal/stdlib/set.rb', line 76
def delete(o)
 @hash.delete(o)
 self
end

81
82
83
84
85
86

# File 'opal/stdlib/set.rb', line 81
def delete?(o)
 if include?(o)
 delete(o)
 self
 end
end

88
89
90
91
92
93
94

# File 'opal/stdlib/set.rb', line 88
def delete_if
 return enum_for(:delete_if) unless block_given?
 # @hash.delete_if should be faster, but using it breaks the order
 # of enumeration in subclasses.
 select { |o| yield o }.each { |o| @hash.delete(o) }
 self
end

22
23
24
25

# File 'opal/stdlib/set.rb', line 22
def dup
 result = self.class.new
 result.merge(self)
end

104
105
106
107
108

# File 'opal/stdlib/set.rb', line 104
def each(&block)
 return enum_for(:each) unless block_given?
 @hash.each_key(&block)
 self
end

110
111
112

# File 'opal/stdlib/set.rb', line 110
def empty?
 @hash.empty?
end

114
115
116

# File 'opal/stdlib/set.rb', line 114
def eql?(other)
 @hash.eql?(other.instance_eval { @hash })
end

123
124
125

# File 'opal/stdlib/set.rb', line 123
def include?(o)
 @hash.include?(o)
end

36
37
38

# File 'opal/stdlib/set.rb', line 36
def inspect
 "#<Set: {#{to_a.join(',')}}>"
end

128
129
130
131

# File 'opal/stdlib/set.rb', line 128
def merge(enum)
 enum.each { |item| add item }
 self
end

181
182
183
184
185

# File 'opal/stdlib/set.rb', line 181
def proper_subset?(set)
 set.is_a?(Set ) || raise(ArgumentError, 'value must be a set')
 return false if set.size <= size
 all? { |o| set.include?(o) }
end

165
166
167
168
169

# File 'opal/stdlib/set.rb', line 165
def proper_superset?(set)
 set.is_a?(Set ) || raise(ArgumentError, 'value must be a set')
 return false if size <= set.size
 set.all? { |o| include?(o) }
end

133
134
135
136
137
138

# File 'opal/stdlib/set.rb', line 133
def replace(enum)
 clear
 merge(enum)
 self
end

140
141
142

# File 'opal/stdlib/set.rb', line 140
def size
 @hash.size
end

173
174
175
176
177

# File 'opal/stdlib/set.rb', line 173
def subset?(set)
 set.is_a?(Set ) || raise(ArgumentError, 'value must be a set')
 return false if set.size < size
 all? { |o| set.include?(o) }
end

145
146
147
148

# File 'opal/stdlib/set.rb', line 145
def subtract(enum)
 enum.each { |item| delete item }
 self
end

157
158
159
160
161

# File 'opal/stdlib/set.rb', line 157
def superset?(set)
 set.is_a?(Set ) || raise(ArgumentError, 'value must be a set')
 return false if size < set.size
 set.all? { |o| include?(o) }
end

192
193
194

# File 'opal/stdlib/set.rb', line 192
def to_a
 @hash.keys
end

150
151
152
153
154
155

# File 'opal/stdlib/set.rb', line 150
def |(enum)
 unless enum.respond_to? :each
 raise ArgumentError, 'value must be enumerable'
 end
 dup.merge(enum)
end