Class: Set

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

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

4
5
6

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

26
27
28
29
30
31
32

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

39
40
41
42
43
44
45
46
47
48
49

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

51
52
53
54

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

97
98
99
100
101
102
103

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

57
58
59
60
61
62
63
64
65

# File 'opal/stdlib/set.rb', line 57
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

119
120
121
122

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

67
68
69
70
71
72

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

75
76
77
78

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

80
81
82
83
84
85
86
87

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

89
90
91
92
93
94
95

# File 'opal/stdlib/set.rb', line 89
def delete_if
 block_given? or return enum_for(__method__)
 # @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

21
22
23
24

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

105
106
107
108
109

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

111
112
113

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

115
116
117

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

124
125
126

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

35
36
37

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

129
130
131
132

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

134
135
136
137
138
139

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

141
142
143

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

146
147
148
149

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

161
162
163

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

151
152
153
154
155
156

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