set 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/.github/workflows/test.yml +24 -0
- data/.gitignore +8 -0
- data/Gemfile +7 -0
- data/LICENSE.txt +22 -0
- data/README.md +71 -0
- data/Rakefile +10 -0
- data/bin/console +14 -0
- data/bin/setup +8 -0
- data/lib/set.rb +910 -0
- data/set.gemspec +24 -0
- metadata +56 -0
checksums.yaml
ADDED
@@ -0,0 +1,7 @@
|
|
1
|
+
---
|
2
|
+
SHA256:
|
3
|
+
metadata.gz: f9eb75e23fd8d5290c7916cd504b9da72dce5d0940e8b288b0e1826dcdcbdd8e
|
4
|
+
data.tar.gz: 87b299beecbd72dbf00f92f1ac0ab6ff1253bf130102a75802b8df790c88612f
|
5
|
+
SHA512:
|
6
|
+
metadata.gz: cfa29111fe6e2c0013fbdc6a74e8efc77559845d878e98647e58572e3d5b052f98601f46848a750fa24dae8505fbc6b4237665ec66200f384c73477231e9a25b
|
7
|
+
data.tar.gz: 6029650bfe5cc14f1b1716b9da47b933264b909ffd613b85a8b4ab73e147a996da6c574e274cb8845eb3f4748534335e6e8507e22ab54e1bccc00049e612f45c
|
@@ -0,0 +1,24 @@
|
|
1
|
+
name: test
|
2
|
+
|
3
|
+
on: [push, pull_request]
|
4
|
+
|
5
|
+
jobs:
|
6
|
+
build:
|
7
|
+
name: build (${{ matrix.ruby }} / ${{ matrix.os }})
|
8
|
+
strategy:
|
9
|
+
matrix:
|
10
|
+
ruby: [ 2.7, 2.6, 2.5, head ]
|
11
|
+
os: [ ubuntu-latest, macos-latest ]
|
12
|
+
runs-on: ${{ matrix.os }}
|
13
|
+
steps:
|
14
|
+
- uses: actions/checkout@master
|
15
|
+
- name: Set up Ruby
|
16
|
+
uses: ruby/setup-ruby@v1
|
17
|
+
with:
|
18
|
+
ruby-version: ${{ matrix.ruby }}
|
19
|
+
- name: Install dependencies
|
20
|
+
run: |
|
21
|
+
gem install bundler --no-document
|
22
|
+
bundle install
|
23
|
+
- name: Run test
|
24
|
+
run: rake test
|
data/.gitignore
ADDED
data/Gemfile
ADDED
data/LICENSE.txt
ADDED
@@ -0,0 +1,22 @@
|
|
1
|
+
Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
|
2
|
+
|
3
|
+
Redistribution and use in source and binary forms, with or without
|
4
|
+
modification, are permitted provided that the following conditions
|
5
|
+
are met:
|
6
|
+
1. Redistributions of source code must retain the above copyright
|
7
|
+
notice, this list of conditions and the following disclaimer.
|
8
|
+
2. Redistributions in binary form must reproduce the above copyright
|
9
|
+
notice, this list of conditions and the following disclaimer in the
|
10
|
+
documentation and/or other materials provided with the distribution.
|
11
|
+
|
12
|
+
THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
13
|
+
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
14
|
+
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
15
|
+
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
16
|
+
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
17
|
+
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
18
|
+
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
19
|
+
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
20
|
+
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
21
|
+
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
22
|
+
SUCH DAMAGE.
|
data/README.md
ADDED
@@ -0,0 +1,71 @@
|
|
1
|
+
# Set
|
2
|
+
|
3
|
+
|
4
|
+
Set implements a collection of unordered values with no duplicates.
|
5
|
+
This is a hybrid of Array's intuitive inter-operation facilities and
|
6
|
+
Hash's fast lookup.
|
7
|
+
|
8
|
+
Set is easy to use with Enumerable objects (implementing +each+).
|
9
|
+
Most of the initializer methods and binary operators accept generic
|
10
|
+
Enumerable objects besides sets and arrays. An Enumerable object
|
11
|
+
can be converted to Set using the +to_set+ method.
|
12
|
+
|
13
|
+
Set uses Hash as storage, so you must note the following points:
|
14
|
+
|
15
|
+
* Equality of elements is determined according to Object#eql? and
|
16
|
+
Object#hash. Use Set#compare_by_identity to make a set compare
|
17
|
+
its elements by their identity.
|
18
|
+
* Set assumes that the identity of each element does not change
|
19
|
+
while it is stored. Modifying an element of a set will render the
|
20
|
+
set to an unreliable state.
|
21
|
+
* When a string is to be stored, a frozen copy of the string is
|
22
|
+
stored instead unless the original string is already frozen.
|
23
|
+
|
24
|
+
## Installation
|
25
|
+
|
26
|
+
Add this line to your application's Gemfile:
|
27
|
+
|
28
|
+
```ruby
|
29
|
+
gem 'set'
|
30
|
+
```
|
31
|
+
|
32
|
+
And then execute:
|
33
|
+
|
34
|
+
$ bundle install
|
35
|
+
|
36
|
+
Or install it yourself as:
|
37
|
+
|
38
|
+
$ gem install set
|
39
|
+
|
40
|
+
## Usage
|
41
|
+
|
42
|
+
### Comparison
|
43
|
+
|
44
|
+
The comparison operators <, >, <=, and >= are implemented as
|
45
|
+
shorthand for the {proper_,}{subset?,superset?} methods. However,
|
46
|
+
the <=> operator is intentionally left out because not every pair of
|
47
|
+
sets is comparable ({x, y} vs. {x, z} for example).
|
48
|
+
|
49
|
+
### Example
|
50
|
+
|
51
|
+
```ruby
|
52
|
+
require 'set'
|
53
|
+
s1 = Set[1, 2] #=> #<Set: {1, 2}>
|
54
|
+
s2 = [1, 2].to_set #=> #<Set: {1, 2}>
|
55
|
+
s1 == s2 #=> true
|
56
|
+
s1.add("foo") #=> #<Set: {1, 2, "foo"}>
|
57
|
+
s1.merge([2, 6]) #=> #<Set: {1, 2, "foo", 6}>
|
58
|
+
s1.subset?(s2) #=> false
|
59
|
+
s2.subset?(s1) #=> true
|
60
|
+
```
|
61
|
+
|
62
|
+
## Development
|
63
|
+
|
64
|
+
After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
|
65
|
+
|
66
|
+
To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
|
67
|
+
|
68
|
+
## Contributing
|
69
|
+
|
70
|
+
Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/set.
|
71
|
+
|
data/Rakefile
ADDED
data/bin/console
ADDED
@@ -0,0 +1,14 @@
|
|
1
|
+
#!/usr/bin/env ruby
|
2
|
+
|
3
|
+
require "bundler/setup"
|
4
|
+
require "set"
|
5
|
+
|
6
|
+
# You can add fixtures and/or initialization code here to make experimenting
|
7
|
+
# with your gem easier. You can also use a different console, if you like.
|
8
|
+
|
9
|
+
# (If you use this, don't forget to add pry to your Gemfile!)
|
10
|
+
# require "pry"
|
11
|
+
# Pry.start
|
12
|
+
|
13
|
+
require "irb"
|
14
|
+
IRB.start(__FILE__)
|
data/bin/setup
ADDED
data/lib/set.rb
ADDED
@@ -0,0 +1,910 @@
|
|
1
|
+
#--
|
2
|
+
# frozen_string_literal: true
|
3
|
+
#
|
4
|
+
# set.rb - defines the Set class
|
5
|
+
#++
|
6
|
+
# Copyright (c) 2002-2016 Akinori MUSHA <knu@iDaemons.org>
|
7
|
+
#
|
8
|
+
# Documentation by Akinori MUSHA and Gavin Sinclair.
|
9
|
+
#
|
10
|
+
# All rights reserved. You can redistribute and/or modify it under the same
|
11
|
+
# terms as Ruby.
|
12
|
+
#
|
13
|
+
# $Id$
|
14
|
+
#
|
15
|
+
# == Overview
|
16
|
+
#
|
17
|
+
# This library provides the Set class, which deals with a collection
|
18
|
+
# of unordered values with no duplicates. It is a hybrid of Array's
|
19
|
+
# intuitive inter-operation facilities and Hash's fast lookup. If you
|
20
|
+
# need to keep values sorted in some order, use the SortedSet class.
|
21
|
+
#
|
22
|
+
# The method +to_set+ is added to Enumerable for convenience.
|
23
|
+
#
|
24
|
+
# See the Set and SortedSet documentation for examples of usage.
|
25
|
+
|
26
|
+
|
27
|
+
#
|
28
|
+
# Set implements a collection of unordered values with no duplicates.
|
29
|
+
# This is a hybrid of Array's intuitive inter-operation facilities and
|
30
|
+
# Hash's fast lookup.
|
31
|
+
#
|
32
|
+
# Set is easy to use with Enumerable objects (implementing +each+).
|
33
|
+
# Most of the initializer methods and binary operators accept generic
|
34
|
+
# Enumerable objects besides sets and arrays. An Enumerable object
|
35
|
+
# can be converted to Set using the +to_set+ method.
|
36
|
+
#
|
37
|
+
# Set uses Hash as storage, so you must note the following points:
|
38
|
+
#
|
39
|
+
# * Equality of elements is determined according to Object#eql? and
|
40
|
+
# Object#hash. Use Set#compare_by_identity to make a set compare
|
41
|
+
# its elements by their identity.
|
42
|
+
# * Set assumes that the identity of each element does not change
|
43
|
+
# while it is stored. Modifying an element of a set will render the
|
44
|
+
# set to an unreliable state.
|
45
|
+
# * When a string is to be stored, a frozen copy of the string is
|
46
|
+
# stored instead unless the original string is already frozen.
|
47
|
+
#
|
48
|
+
# == Comparison
|
49
|
+
#
|
50
|
+
# The comparison operators <, >, <=, and >= are implemented as
|
51
|
+
# shorthand for the {proper_,}{subset?,superset?} methods. However,
|
52
|
+
# the <=> operator is intentionally left out because not every pair of
|
53
|
+
# sets is comparable ({x, y} vs. {x, z} for example).
|
54
|
+
#
|
55
|
+
# == Example
|
56
|
+
#
|
57
|
+
# require 'set'
|
58
|
+
# s1 = Set[1, 2] #=> #<Set: {1, 2}>
|
59
|
+
# s2 = [1, 2].to_set #=> #<Set: {1, 2}>
|
60
|
+
# s1 == s2 #=> true
|
61
|
+
# s1.add("foo") #=> #<Set: {1, 2, "foo"}>
|
62
|
+
# s1.merge([2, 6]) #=> #<Set: {1, 2, "foo", 6}>
|
63
|
+
# s1.subset?(s2) #=> false
|
64
|
+
# s2.subset?(s1) #=> true
|
65
|
+
#
|
66
|
+
# == Contact
|
67
|
+
#
|
68
|
+
# - Akinori MUSHA <knu@iDaemons.org> (current maintainer)
|
69
|
+
#
|
70
|
+
class Set
|
71
|
+
include Enumerable
|
72
|
+
|
73
|
+
# Creates a new set containing the given objects.
|
74
|
+
#
|
75
|
+
# Set[1, 2] # => #<Set: {1, 2}>
|
76
|
+
# Set[1, 2, 1] # => #<Set: {1, 2}>
|
77
|
+
# Set[1, 'c', :s] # => #<Set: {1, "c", :s}>
|
78
|
+
def self.[](*ary)
|
79
|
+
new(ary)
|
80
|
+
end
|
81
|
+
|
82
|
+
# Creates a new set containing the elements of the given enumerable
|
83
|
+
# object.
|
84
|
+
#
|
85
|
+
# If a block is given, the elements of enum are preprocessed by the
|
86
|
+
# given block.
|
87
|
+
#
|
88
|
+
# Set.new([1, 2]) #=> #<Set: {1, 2}>
|
89
|
+
# Set.new([1, 2, 1]) #=> #<Set: {1, 2}>
|
90
|
+
# Set.new([1, 'c', :s]) #=> #<Set: {1, "c", :s}>
|
91
|
+
# Set.new(1..5) #=> #<Set: {1, 2, 3, 4, 5}>
|
92
|
+
# Set.new([1, 2, 3]) { |x| x * x } #=> #<Set: {1, 4, 9}>
|
93
|
+
def initialize(enum = nil, &block) # :yields: o
|
94
|
+
@hash ||= Hash.new(false)
|
95
|
+
|
96
|
+
enum.nil? and return
|
97
|
+
|
98
|
+
if block
|
99
|
+
do_with_enum(enum) { |o| add(block[o]) }
|
100
|
+
else
|
101
|
+
merge(enum)
|
102
|
+
end
|
103
|
+
end
|
104
|
+
|
105
|
+
# Makes the set compare its elements by their identity and returns
|
106
|
+
# self. This method may not be supported by all subclasses of Set.
|
107
|
+
def compare_by_identity
|
108
|
+
if @hash.respond_to?(:compare_by_identity)
|
109
|
+
@hash.compare_by_identity
|
110
|
+
self
|
111
|
+
else
|
112
|
+
raise NotImplementedError, "#{self.class.name}\##{__method__} is not implemented"
|
113
|
+
end
|
114
|
+
end
|
115
|
+
|
116
|
+
# Returns true if the set will compare its elements by their
|
117
|
+
# identity. Also see Set#compare_by_identity.
|
118
|
+
def compare_by_identity?
|
119
|
+
@hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity?
|
120
|
+
end
|
121
|
+
|
122
|
+
def do_with_enum(enum, &block) # :nodoc:
|
123
|
+
if enum.respond_to?(:each_entry)
|
124
|
+
enum.each_entry(&block) if block
|
125
|
+
elsif enum.respond_to?(:each)
|
126
|
+
enum.each(&block) if block
|
127
|
+
else
|
128
|
+
raise ArgumentError, "value must be enumerable"
|
129
|
+
end
|
130
|
+
end
|
131
|
+
private :do_with_enum
|
132
|
+
|
133
|
+
# Dup internal hash.
|
134
|
+
def initialize_dup(orig)
|
135
|
+
super
|
136
|
+
@hash = orig.instance_variable_get(:@hash).dup
|
137
|
+
end
|
138
|
+
|
139
|
+
# Clone internal hash.
|
140
|
+
def initialize_clone(orig, freeze: nil)
|
141
|
+
super
|
142
|
+
@hash = orig.instance_variable_get(:@hash).clone(freeze: freeze)
|
143
|
+
end
|
144
|
+
|
145
|
+
def freeze # :nodoc:
|
146
|
+
@hash.freeze
|
147
|
+
super
|
148
|
+
end
|
149
|
+
|
150
|
+
# Returns the number of elements.
|
151
|
+
def size
|
152
|
+
@hash.size
|
153
|
+
end
|
154
|
+
alias length size
|
155
|
+
|
156
|
+
# Returns true if the set contains no elements.
|
157
|
+
def empty?
|
158
|
+
@hash.empty?
|
159
|
+
end
|
160
|
+
|
161
|
+
# Removes all elements and returns self.
|
162
|
+
#
|
163
|
+
# set = Set[1, 'c', :s] #=> #<Set: {1, "c", :s}>
|
164
|
+
# set.clear #=> #<Set: {}>
|
165
|
+
# set #=> #<Set: {}>
|
166
|
+
def clear
|
167
|
+
@hash.clear
|
168
|
+
self
|
169
|
+
end
|
170
|
+
|
171
|
+
# Replaces the contents of the set with the contents of the given
|
172
|
+
# enumerable object and returns self.
|
173
|
+
#
|
174
|
+
# set = Set[1, 'c', :s] #=> #<Set: {1, "c", :s}>
|
175
|
+
# set.replace([1, 2]) #=> #<Set: {1, 2}>
|
176
|
+
# set #=> #<Set: {1, 2}>
|
177
|
+
def replace(enum)
|
178
|
+
if enum.instance_of?(self.class)
|
179
|
+
@hash.replace(enum.instance_variable_get(:@hash))
|
180
|
+
self
|
181
|
+
else
|
182
|
+
do_with_enum(enum) # make sure enum is enumerable before calling clear
|
183
|
+
clear
|
184
|
+
merge(enum)
|
185
|
+
end
|
186
|
+
end
|
187
|
+
|
188
|
+
# Converts the set to an array. The order of elements is uncertain.
|
189
|
+
#
|
190
|
+
# Set[1, 2].to_a #=> [1, 2]
|
191
|
+
# Set[1, 'c', :s].to_a #=> [1, "c", :s]
|
192
|
+
def to_a
|
193
|
+
@hash.keys
|
194
|
+
end
|
195
|
+
|
196
|
+
# Returns self if no arguments are given. Otherwise, converts the
|
197
|
+
# set to another with klass.new(self, *args, &block).
|
198
|
+
#
|
199
|
+
# In subclasses, returns klass.new(self, *args, &block) unless
|
200
|
+
# overridden.
|
201
|
+
def to_set(klass = Set, *args, &block)
|
202
|
+
return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
|
203
|
+
klass.new(self, *args, &block)
|
204
|
+
end
|
205
|
+
|
206
|
+
def flatten_merge(set, seen = Set.new) # :nodoc:
|
207
|
+
set.each { |e|
|
208
|
+
if e.is_a?(Set)
|
209
|
+
if seen.include?(e_id = e.object_id)
|
210
|
+
raise ArgumentError, "tried to flatten recursive Set"
|
211
|
+
end
|
212
|
+
|
213
|
+
seen.add(e_id)
|
214
|
+
flatten_merge(e, seen)
|
215
|
+
seen.delete(e_id)
|
216
|
+
else
|
217
|
+
add(e)
|
218
|
+
end
|
219
|
+
}
|
220
|
+
|
221
|
+
self
|
222
|
+
end
|
223
|
+
protected :flatten_merge
|
224
|
+
|
225
|
+
# Returns a new set that is a copy of the set, flattening each
|
226
|
+
# containing set recursively.
|
227
|
+
def flatten
|
228
|
+
self.class.new.flatten_merge(self)
|
229
|
+
end
|
230
|
+
|
231
|
+
# Equivalent to Set#flatten, but replaces the receiver with the
|
232
|
+
# result in place. Returns nil if no modifications were made.
|
233
|
+
def flatten!
|
234
|
+
replace(flatten()) if any? { |e| e.is_a?(Set) }
|
235
|
+
end
|
236
|
+
|
237
|
+
# Returns true if the set contains the given object.
|
238
|
+
#
|
239
|
+
# Note that <code>include?</code> and <code>member?</code> do not test member
|
240
|
+
# equality using <code>==</code> as do other Enumerables.
|
241
|
+
#
|
242
|
+
# See also Enumerable#include?
|
243
|
+
def include?(o)
|
244
|
+
@hash[o]
|
245
|
+
end
|
246
|
+
alias member? include?
|
247
|
+
|
248
|
+
# Returns true if the set is a superset of the given set.
|
249
|
+
def superset?(set)
|
250
|
+
case
|
251
|
+
when set.instance_of?(self.class) && @hash.respond_to?(:>=)
|
252
|
+
@hash >= set.instance_variable_get(:@hash)
|
253
|
+
when set.is_a?(Set)
|
254
|
+
size >= set.size && set.all? { |o| include?(o) }
|
255
|
+
else
|
256
|
+
raise ArgumentError, "value must be a set"
|
257
|
+
end
|
258
|
+
end
|
259
|
+
alias >= superset?
|
260
|
+
|
261
|
+
# Returns true if the set is a proper superset of the given set.
|
262
|
+
def proper_superset?(set)
|
263
|
+
case
|
264
|
+
when set.instance_of?(self.class) && @hash.respond_to?(:>)
|
265
|
+
@hash > set.instance_variable_get(:@hash)
|
266
|
+
when set.is_a?(Set)
|
267
|
+
size > set.size && set.all? { |o| include?(o) }
|
268
|
+
else
|
269
|
+
raise ArgumentError, "value must be a set"
|
270
|
+
end
|
271
|
+
end
|
272
|
+
alias > proper_superset?
|
273
|
+
|
274
|
+
# Returns true if the set is a subset of the given set.
|
275
|
+
def subset?(set)
|
276
|
+
case
|
277
|
+
when set.instance_of?(self.class) && @hash.respond_to?(:<=)
|
278
|
+
@hash <= set.instance_variable_get(:@hash)
|
279
|
+
when set.is_a?(Set)
|
280
|
+
size <= set.size && all? { |o| set.include?(o) }
|
281
|
+
else
|
282
|
+
raise ArgumentError, "value must be a set"
|
283
|
+
end
|
284
|
+
end
|
285
|
+
alias <= subset?
|
286
|
+
|
287
|
+
# Returns true if the set is a proper subset of the given set.
|
288
|
+
def proper_subset?(set)
|
289
|
+
case
|
290
|
+
when set.instance_of?(self.class) && @hash.respond_to?(:<)
|
291
|
+
@hash < set.instance_variable_get(:@hash)
|
292
|
+
when set.is_a?(Set)
|
293
|
+
size < set.size && all? { |o| set.include?(o) }
|
294
|
+
else
|
295
|
+
raise ArgumentError, "value must be a set"
|
296
|
+
end
|
297
|
+
end
|
298
|
+
alias < proper_subset?
|
299
|
+
|
300
|
+
# Returns true if the set and the given set have at least one
|
301
|
+
# element in common.
|
302
|
+
#
|
303
|
+
# Set[1, 2, 3].intersect? Set[4, 5] #=> false
|
304
|
+
# Set[1, 2, 3].intersect? Set[3, 4] #=> true
|
305
|
+
def intersect?(set)
|
306
|
+
set.is_a?(Set) or raise ArgumentError, "value must be a set"
|
307
|
+
if size < set.size
|
308
|
+
any? { |o| set.include?(o) }
|
309
|
+
else
|
310
|
+
set.any? { |o| include?(o) }
|
311
|
+
end
|
312
|
+
end
|
313
|
+
|
314
|
+
# Returns true if the set and the given set have no element in
|
315
|
+
# common. This method is the opposite of +intersect?+.
|
316
|
+
#
|
317
|
+
# Set[1, 2, 3].disjoint? Set[3, 4] #=> false
|
318
|
+
# Set[1, 2, 3].disjoint? Set[4, 5] #=> true
|
319
|
+
def disjoint?(set)
|
320
|
+
!intersect?(set)
|
321
|
+
end
|
322
|
+
|
323
|
+
# Calls the given block once for each element in the set, passing
|
324
|
+
# the element as parameter. Returns an enumerator if no block is
|
325
|
+
# given.
|
326
|
+
def each(&block)
|
327
|
+
block or return enum_for(__method__) { size }
|
328
|
+
@hash.each_key(&block)
|
329
|
+
self
|
330
|
+
end
|
331
|
+
|
332
|
+
# Adds the given object to the set and returns self. Use +merge+ to
|
333
|
+
# add many elements at once.
|
334
|
+
#
|
335
|
+
# Set[1, 2].add(3) #=> #<Set: {1, 2, 3}>
|
336
|
+
# Set[1, 2].add([3, 4]) #=> #<Set: {1, 2, [3, 4]}>
|
337
|
+
# Set[1, 2].add(2) #=> #<Set: {1, 2}>
|
338
|
+
def add(o)
|
339
|
+
@hash[o] = true
|
340
|
+
self
|
341
|
+
end
|
342
|
+
alias << add
|
343
|
+
|
344
|
+
# Adds the given object to the set and returns self. If the
|
345
|
+
# object is already in the set, returns nil.
|
346
|
+
#
|
347
|
+
# Set[1, 2].add?(3) #=> #<Set: {1, 2, 3}>
|
348
|
+
# Set[1, 2].add?([3, 4]) #=> #<Set: {1, 2, [3, 4]}>
|
349
|
+
# Set[1, 2].add?(2) #=> nil
|
350
|
+
def add?(o)
|
351
|
+
add(o) unless include?(o)
|
352
|
+
end
|
353
|
+
|
354
|
+
# Deletes the given object from the set and returns self. Use +subtract+ to
|
355
|
+
# delete many items at once.
|
356
|
+
def delete(o)
|
357
|
+
@hash.delete(o)
|
358
|
+
self
|
359
|
+
end
|
360
|
+
|
361
|
+
# Deletes the given object from the set and returns self. If the
|
362
|
+
# object is not in the set, returns nil.
|
363
|
+
def delete?(o)
|
364
|
+
delete(o) if include?(o)
|
365
|
+
end
|
366
|
+
|
367
|
+
# Deletes every element of the set for which block evaluates to
|
368
|
+
# true, and returns self. Returns an enumerator if no block is
|
369
|
+
# given.
|
370
|
+
def delete_if
|
371
|
+
block_given? or return enum_for(__method__) { size }
|
372
|
+
# @hash.delete_if should be faster, but using it breaks the order
|
373
|
+
# of enumeration in subclasses.
|
374
|
+
select { |o| yield o }.each { |o| @hash.delete(o) }
|
375
|
+
self
|
376
|
+
end
|
377
|
+
|
378
|
+
# Deletes every element of the set for which block evaluates to
|
379
|
+
# false, and returns self. Returns an enumerator if no block is
|
380
|
+
# given.
|
381
|
+
def keep_if
|
382
|
+
block_given? or return enum_for(__method__) { size }
|
383
|
+
# @hash.keep_if should be faster, but using it breaks the order of
|
384
|
+
# enumeration in subclasses.
|
385
|
+
reject { |o| yield o }.each { |o| @hash.delete(o) }
|
386
|
+
self
|
387
|
+
end
|
388
|
+
|
389
|
+
# Replaces the elements with ones returned by collect().
|
390
|
+
# Returns an enumerator if no block is given.
|
391
|
+
def collect!
|
392
|
+
block_given? or return enum_for(__method__) { size }
|
393
|
+
set = self.class.new
|
394
|
+
each { |o| set << yield(o) }
|
395
|
+
replace(set)
|
396
|
+
end
|
397
|
+
alias map! collect!
|
398
|
+
|
399
|
+
# Equivalent to Set#delete_if, but returns nil if no changes were
|
400
|
+
# made. Returns an enumerator if no block is given.
|
401
|
+
def reject!(&block)
|
402
|
+
block or return enum_for(__method__) { size }
|
403
|
+
n = size
|
404
|
+
delete_if(&block)
|
405
|
+
self if size != n
|
406
|
+
end
|
407
|
+
|
408
|
+
# Equivalent to Set#keep_if, but returns nil if no changes were
|
409
|
+
# made. Returns an enumerator if no block is given.
|
410
|
+
def select!(&block)
|
411
|
+
block or return enum_for(__method__) { size }
|
412
|
+
n = size
|
413
|
+
keep_if(&block)
|
414
|
+
self if size != n
|
415
|
+
end
|
416
|
+
|
417
|
+
# Equivalent to Set#select!
|
418
|
+
alias filter! select!
|
419
|
+
|
420
|
+
# Merges the elements of the given enumerable object to the set and
|
421
|
+
# returns self.
|
422
|
+
def merge(enum)
|
423
|
+
if enum.instance_of?(self.class)
|
424
|
+
@hash.update(enum.instance_variable_get(:@hash))
|
425
|
+
else
|
426
|
+
do_with_enum(enum) { |o| add(o) }
|
427
|
+
end
|
428
|
+
|
429
|
+
self
|
430
|
+
end
|
431
|
+
|
432
|
+
# Deletes every element that appears in the given enumerable object
|
433
|
+
# and returns self.
|
434
|
+
def subtract(enum)
|
435
|
+
do_with_enum(enum) { |o| delete(o) }
|
436
|
+
self
|
437
|
+
end
|
438
|
+
|
439
|
+
# Returns a new set built by merging the set and the elements of the
|
440
|
+
# given enumerable object.
|
441
|
+
#
|
442
|
+
# Set[1, 2, 3] | Set[2, 4, 5] #=> #<Set: {1, 2, 3, 4, 5}>
|
443
|
+
# Set[1, 5, 'z'] | (1..6) #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>
|
444
|
+
def |(enum)
|
445
|
+
dup.merge(enum)
|
446
|
+
end
|
447
|
+
alias + |
|
448
|
+
alias union |
|
449
|
+
|
450
|
+
# Returns a new set built by duplicating the set, removing every
|
451
|
+
# element that appears in the given enumerable object.
|
452
|
+
#
|
453
|
+
# Set[1, 3, 5] - Set[1, 5] #=> #<Set: {3}>
|
454
|
+
# Set['a', 'b', 'z'] - ['a', 'c'] #=> #<Set: {"b", "z"}>
|
455
|
+
def -(enum)
|
456
|
+
dup.subtract(enum)
|
457
|
+
end
|
458
|
+
alias difference -
|
459
|
+
|
460
|
+
# Returns a new set containing elements common to the set and the
|
461
|
+
# given enumerable object.
|
462
|
+
#
|
463
|
+
# Set[1, 3, 5] & Set[3, 2, 1] #=> #<Set: {3, 1}>
|
464
|
+
# Set['a', 'b', 'z'] & ['a', 'b', 'c'] #=> #<Set: {"a", "b"}>
|
465
|
+
def &(enum)
|
466
|
+
n = self.class.new
|
467
|
+
if enum.is_a?(Set)
|
468
|
+
if enum.size > size
|
469
|
+
each { |o| n.add(o) if enum.include?(o) }
|
470
|
+
else
|
471
|
+
enum.each { |o| n.add(o) if include?(o) }
|
472
|
+
end
|
473
|
+
else
|
474
|
+
do_with_enum(enum) { |o| n.add(o) if include?(o) }
|
475
|
+
end
|
476
|
+
n
|
477
|
+
end
|
478
|
+
alias intersection &
|
479
|
+
|
480
|
+
# Returns a new set containing elements exclusive between the set
|
481
|
+
# and the given enumerable object. (set ^ enum) is equivalent to
|
482
|
+
# ((set | enum) - (set & enum)).
|
483
|
+
#
|
484
|
+
# Set[1, 2] ^ Set[2, 3] #=> #<Set: {3, 1}>
|
485
|
+
# Set[1, 'b', 'c'] ^ ['b', 'd'] #=> #<Set: {"d", 1, "c"}>
|
486
|
+
def ^(enum)
|
487
|
+
n = Set.new(enum)
|
488
|
+
each { |o| n.add(o) unless n.delete?(o) }
|
489
|
+
n
|
490
|
+
end
|
491
|
+
|
492
|
+
# Returns true if two sets are equal. The equality of each couple
|
493
|
+
# of elements is defined according to Object#eql?.
|
494
|
+
#
|
495
|
+
# Set[1, 2] == Set[2, 1] #=> true
|
496
|
+
# Set[1, 3, 5] == Set[1, 5] #=> false
|
497
|
+
# Set['a', 'b', 'c'] == Set['a', 'c', 'b'] #=> true
|
498
|
+
# Set['a', 'b', 'c'] == ['a', 'c', 'b'] #=> false
|
499
|
+
def ==(other)
|
500
|
+
if self.equal?(other)
|
501
|
+
true
|
502
|
+
elsif other.instance_of?(self.class)
|
503
|
+
@hash == other.instance_variable_get(:@hash)
|
504
|
+
elsif other.is_a?(Set) && self.size == other.size
|
505
|
+
other.all? { |o| @hash.include?(o) }
|
506
|
+
else
|
507
|
+
false
|
508
|
+
end
|
509
|
+
end
|
510
|
+
|
511
|
+
def hash # :nodoc:
|
512
|
+
@hash.hash
|
513
|
+
end
|
514
|
+
|
515
|
+
def eql?(o) # :nodoc:
|
516
|
+
return false unless o.is_a?(Set)
|
517
|
+
@hash.eql?(o.instance_variable_get(:@hash))
|
518
|
+
end
|
519
|
+
|
520
|
+
# Resets the internal state after modification to existing elements
|
521
|
+
# and returns self.
|
522
|
+
#
|
523
|
+
# Elements will be reindexed and deduplicated.
|
524
|
+
def reset
|
525
|
+
if @hash.respond_to?(:rehash)
|
526
|
+
@hash.rehash # This should perform frozenness check.
|
527
|
+
else
|
528
|
+
raise FrozenError, "can't modify frozen #{self.class.name}" if frozen?
|
529
|
+
end
|
530
|
+
self
|
531
|
+
end
|
532
|
+
|
533
|
+
# Returns true if the given object is a member of the set,
|
534
|
+
# and false otherwise.
|
535
|
+
#
|
536
|
+
# Used in case statements:
|
537
|
+
#
|
538
|
+
# require 'set'
|
539
|
+
#
|
540
|
+
# case :apple
|
541
|
+
# when Set[:potato, :carrot]
|
542
|
+
# "vegetable"
|
543
|
+
# when Set[:apple, :banana]
|
544
|
+
# "fruit"
|
545
|
+
# end
|
546
|
+
# # => "fruit"
|
547
|
+
#
|
548
|
+
# Or by itself:
|
549
|
+
#
|
550
|
+
# Set[1, 2, 3] === 2 #=> true
|
551
|
+
# Set[1, 2, 3] === 4 #=> false
|
552
|
+
#
|
553
|
+
alias === include?
|
554
|
+
|
555
|
+
# Classifies the set by the return value of the given block and
|
556
|
+
# returns a hash of {value => set of elements} pairs. The block is
|
557
|
+
# called once for each element of the set, passing the element as
|
558
|
+
# parameter.
|
559
|
+
#
|
560
|
+
# require 'set'
|
561
|
+
# files = Set.new(Dir.glob("*.rb"))
|
562
|
+
# hash = files.classify { |f| File.mtime(f).year }
|
563
|
+
# hash #=> {2000=>#<Set: {"a.rb", "b.rb"}>,
|
564
|
+
# # 2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
|
565
|
+
# # 2002=>#<Set: {"f.rb"}>}
|
566
|
+
#
|
567
|
+
# Returns an enumerator if no block is given.
|
568
|
+
def classify # :yields: o
|
569
|
+
block_given? or return enum_for(__method__) { size }
|
570
|
+
|
571
|
+
h = {}
|
572
|
+
|
573
|
+
each { |i|
|
574
|
+
(h[yield(i)] ||= self.class.new).add(i)
|
575
|
+
}
|
576
|
+
|
577
|
+
h
|
578
|
+
end
|
579
|
+
|
580
|
+
# Divides the set into a set of subsets according to the commonality
|
581
|
+
# defined by the given block.
|
582
|
+
#
|
583
|
+
# If the arity of the block is 2, elements o1 and o2 are in common
|
584
|
+
# if block.call(o1, o2) is true. Otherwise, elements o1 and o2 are
|
585
|
+
# in common if block.call(o1) == block.call(o2).
|
586
|
+
#
|
587
|
+
# require 'set'
|
588
|
+
# numbers = Set[1, 3, 4, 6, 9, 10, 11]
|
589
|
+
# set = numbers.divide { |i,j| (i - j).abs == 1 }
|
590
|
+
# set #=> #<Set: {#<Set: {1}>,
|
591
|
+
# # #<Set: {11, 9, 10}>,
|
592
|
+
# # #<Set: {3, 4}>,
|
593
|
+
# # #<Set: {6}>}>
|
594
|
+
#
|
595
|
+
# Returns an enumerator if no block is given.
|
596
|
+
def divide(&func)
|
597
|
+
func or return enum_for(__method__) { size }
|
598
|
+
|
599
|
+
if func.arity == 2
|
600
|
+
require 'tsort'
|
601
|
+
|
602
|
+
class << dig = {} # :nodoc:
|
603
|
+
include TSort
|
604
|
+
|
605
|
+
alias tsort_each_node each_key
|
606
|
+
def tsort_each_child(node, &block)
|
607
|
+
fetch(node).each(&block)
|
608
|
+
end
|
609
|
+
end
|
610
|
+
|
611
|
+
each { |u|
|
612
|
+
dig[u] = a = []
|
613
|
+
each{ |v| func.call(u, v) and a << v }
|
614
|
+
}
|
615
|
+
|
616
|
+
set = Set.new()
|
617
|
+
dig.each_strongly_connected_component { |css|
|
618
|
+
set.add(self.class.new(css))
|
619
|
+
}
|
620
|
+
set
|
621
|
+
else
|
622
|
+
Set.new(classify(&func).values)
|
623
|
+
end
|
624
|
+
end
|
625
|
+
|
626
|
+
InspectKey = :__inspect_key__ # :nodoc:
|
627
|
+
|
628
|
+
# Returns a string containing a human-readable representation of the
|
629
|
+
# set ("#<Set: {element1, element2, ...}>").
|
630
|
+
def inspect
|
631
|
+
ids = (Thread.current[InspectKey] ||= [])
|
632
|
+
|
633
|
+
if ids.include?(object_id)
|
634
|
+
return sprintf('#<%s: {...}>', self.class.name)
|
635
|
+
end
|
636
|
+
|
637
|
+
ids << object_id
|
638
|
+
begin
|
639
|
+
return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
|
640
|
+
ensure
|
641
|
+
ids.pop
|
642
|
+
end
|
643
|
+
end
|
644
|
+
|
645
|
+
alias to_s inspect
|
646
|
+
|
647
|
+
def pretty_print(pp) # :nodoc:
|
648
|
+
pp.text sprintf('#<%s: {', self.class.name)
|
649
|
+
pp.nest(1) {
|
650
|
+
pp.seplist(self) { |o|
|
651
|
+
pp.pp o
|
652
|
+
}
|
653
|
+
}
|
654
|
+
pp.text "}>"
|
655
|
+
end
|
656
|
+
|
657
|
+
def pretty_print_cycle(pp) # :nodoc:
|
658
|
+
pp.text sprintf('#<%s: {%s}>', self.class.name, empty? ? '' : '...')
|
659
|
+
end
|
660
|
+
end
|
661
|
+
|
662
|
+
#
|
663
|
+
# SortedSet implements a Set that guarantees that its elements are
|
664
|
+
# yielded in sorted order (according to the return values of their
|
665
|
+
# #<=> methods) when iterating over them.
|
666
|
+
#
|
667
|
+
# All elements that are added to a SortedSet must respond to the <=>
|
668
|
+
# method for comparison.
|
669
|
+
#
|
670
|
+
# Also, all elements must be <em>mutually comparable</em>: <tt>el1 <=>
|
671
|
+
# el2</tt> must not return <tt>nil</tt> for any elements <tt>el1</tt>
|
672
|
+
# and <tt>el2</tt>, else an ArgumentError will be raised when
|
673
|
+
# iterating over the SortedSet.
|
674
|
+
#
|
675
|
+
# == Example
|
676
|
+
#
|
677
|
+
# require "set"
|
678
|
+
#
|
679
|
+
# set = SortedSet.new([2, 1, 5, 6, 4, 5, 3, 3, 3])
|
680
|
+
# ary = []
|
681
|
+
#
|
682
|
+
# set.each do |obj|
|
683
|
+
# ary << obj
|
684
|
+
# end
|
685
|
+
#
|
686
|
+
# p ary # => [1, 2, 3, 4, 5, 6]
|
687
|
+
#
|
688
|
+
# set2 = SortedSet.new([1, 2, "3"])
|
689
|
+
# set2.each { |obj| } # => raises ArgumentError: comparison of Fixnum with String failed
|
690
|
+
#
|
691
|
+
class SortedSet < Set
|
692
|
+
@@setup = false
|
693
|
+
@@mutex = Mutex.new
|
694
|
+
|
695
|
+
class << self
|
696
|
+
def [](*ary) # :nodoc:
|
697
|
+
new(ary)
|
698
|
+
end
|
699
|
+
|
700
|
+
def setup # :nodoc:
|
701
|
+
@@setup and return
|
702
|
+
|
703
|
+
@@mutex.synchronize do
|
704
|
+
# a hack to shut up warning
|
705
|
+
alias_method :old_init, :initialize
|
706
|
+
|
707
|
+
begin
|
708
|
+
require 'rbtree'
|
709
|
+
|
710
|
+
module_eval <<-END, __FILE__, __LINE__+1
|
711
|
+
def initialize(*args)
|
712
|
+
@hash = RBTree.new
|
713
|
+
super
|
714
|
+
end
|
715
|
+
|
716
|
+
def add(o)
|
717
|
+
o.respond_to?(:<=>) or raise ArgumentError, "value must respond to <=>"
|
718
|
+
super
|
719
|
+
end
|
720
|
+
alias << add
|
721
|
+
END
|
722
|
+
rescue LoadError
|
723
|
+
module_eval <<-END, __FILE__, __LINE__+1
|
724
|
+
def initialize(*args)
|
725
|
+
@keys = nil
|
726
|
+
super
|
727
|
+
end
|
728
|
+
|
729
|
+
def clear
|
730
|
+
@keys = nil
|
731
|
+
super
|
732
|
+
end
|
733
|
+
|
734
|
+
def replace(enum)
|
735
|
+
@keys = nil
|
736
|
+
super
|
737
|
+
end
|
738
|
+
|
739
|
+
def add(o)
|
740
|
+
o.respond_to?(:<=>) or raise ArgumentError, "value must respond to <=>"
|
741
|
+
@keys = nil
|
742
|
+
super
|
743
|
+
end
|
744
|
+
alias << add
|
745
|
+
|
746
|
+
def delete(o)
|
747
|
+
@keys = nil
|
748
|
+
@hash.delete(o)
|
749
|
+
self
|
750
|
+
end
|
751
|
+
|
752
|
+
def delete_if
|
753
|
+
block_given? or return enum_for(__method__) { size }
|
754
|
+
n = @hash.size
|
755
|
+
super
|
756
|
+
@keys = nil if @hash.size != n
|
757
|
+
self
|
758
|
+
end
|
759
|
+
|
760
|
+
def keep_if
|
761
|
+
block_given? or return enum_for(__method__) { size }
|
762
|
+
n = @hash.size
|
763
|
+
super
|
764
|
+
@keys = nil if @hash.size != n
|
765
|
+
self
|
766
|
+
end
|
767
|
+
|
768
|
+
def merge(enum)
|
769
|
+
@keys = nil
|
770
|
+
super
|
771
|
+
end
|
772
|
+
|
773
|
+
def each(&block)
|
774
|
+
block or return enum_for(__method__) { size }
|
775
|
+
to_a.each(&block)
|
776
|
+
self
|
777
|
+
end
|
778
|
+
|
779
|
+
def to_a
|
780
|
+
(@keys = @hash.keys).sort! unless @keys
|
781
|
+
@keys.dup
|
782
|
+
end
|
783
|
+
|
784
|
+
def freeze
|
785
|
+
to_a
|
786
|
+
super
|
787
|
+
end
|
788
|
+
|
789
|
+
def rehash
|
790
|
+
@keys = nil
|
791
|
+
super
|
792
|
+
end
|
793
|
+
END
|
794
|
+
end
|
795
|
+
# a hack to shut up warning
|
796
|
+
remove_method :old_init
|
797
|
+
|
798
|
+
@@setup = true
|
799
|
+
end
|
800
|
+
end
|
801
|
+
end
|
802
|
+
|
803
|
+
def initialize(*args, &block) # :nodoc:
|
804
|
+
SortedSet.setup
|
805
|
+
@keys = nil
|
806
|
+
super
|
807
|
+
end
|
808
|
+
end
|
809
|
+
|
810
|
+
module Enumerable
|
811
|
+
# Makes a set from the enumerable object with given arguments.
|
812
|
+
# Needs to +require "set"+ to use this method.
|
813
|
+
def to_set(klass = Set, *args, &block)
|
814
|
+
klass.new(self, *args, &block)
|
815
|
+
end
|
816
|
+
end
|
817
|
+
|
818
|
+
# =begin
|
819
|
+
# == RestricedSet class
|
820
|
+
# RestricedSet implements a set with restrictions defined by a given
|
821
|
+
# block.
|
822
|
+
#
|
823
|
+
# === Super class
|
824
|
+
# Set
|
825
|
+
#
|
826
|
+
# === Class Methods
|
827
|
+
# --- RestricedSet::new(enum = nil) { |o| ... }
|
828
|
+
# --- RestricedSet::new(enum = nil) { |rset, o| ... }
|
829
|
+
# Creates a new restricted set containing the elements of the given
|
830
|
+
# enumerable object. Restrictions are defined by the given block.
|
831
|
+
#
|
832
|
+
# If the block's arity is 2, it is called with the RestrictedSet
|
833
|
+
# itself and an object to see if the object is allowed to be put in
|
834
|
+
# the set.
|
835
|
+
#
|
836
|
+
# Otherwise, the block is called with an object to see if the object
|
837
|
+
# is allowed to be put in the set.
|
838
|
+
#
|
839
|
+
# === Instance Methods
|
840
|
+
# --- restriction_proc
|
841
|
+
# Returns the restriction procedure of the set.
|
842
|
+
#
|
843
|
+
# =end
|
844
|
+
#
|
845
|
+
# class RestricedSet < Set
|
846
|
+
# def initialize(*args, &block)
|
847
|
+
# @proc = block or raise ArgumentError, "missing a block"
|
848
|
+
#
|
849
|
+
# if @proc.arity == 2
|
850
|
+
# instance_eval %{
|
851
|
+
# def add(o)
|
852
|
+
# @hash[o] = true if @proc.call(self, o)
|
853
|
+
# self
|
854
|
+
# end
|
855
|
+
# alias << add
|
856
|
+
#
|
857
|
+
# def add?(o)
|
858
|
+
# if include?(o) || !@proc.call(self, o)
|
859
|
+
# nil
|
860
|
+
# else
|
861
|
+
# @hash[o] = true
|
862
|
+
# self
|
863
|
+
# end
|
864
|
+
# end
|
865
|
+
#
|
866
|
+
# def replace(enum)
|
867
|
+
# enum.respond_to?(:each) or raise ArgumentError, "value must be enumerable"
|
868
|
+
# clear
|
869
|
+
# enum.each_entry { |o| add(o) }
|
870
|
+
#
|
871
|
+
# self
|
872
|
+
# end
|
873
|
+
#
|
874
|
+
# def merge(enum)
|
875
|
+
# enum.respond_to?(:each) or raise ArgumentError, "value must be enumerable"
|
876
|
+
# enum.each_entry { |o| add(o) }
|
877
|
+
#
|
878
|
+
# self
|
879
|
+
# end
|
880
|
+
# }
|
881
|
+
# else
|
882
|
+
# instance_eval %{
|
883
|
+
# def add(o)
|
884
|
+
# if @proc.call(o)
|
885
|
+
# @hash[o] = true
|
886
|
+
# end
|
887
|
+
# self
|
888
|
+
# end
|
889
|
+
# alias << add
|
890
|
+
#
|
891
|
+
# def add?(o)
|
892
|
+
# if include?(o) || !@proc.call(o)
|
893
|
+
# nil
|
894
|
+
# else
|
895
|
+
# @hash[o] = true
|
896
|
+
# self
|
897
|
+
# end
|
898
|
+
# end
|
899
|
+
# }
|
900
|
+
# end
|
901
|
+
#
|
902
|
+
# super(*args)
|
903
|
+
# end
|
904
|
+
#
|
905
|
+
# def restriction_proc
|
906
|
+
# @proc
|
907
|
+
# end
|
908
|
+
# end
|
909
|
+
|
910
|
+
# Tests have been moved to test/test_set.rb.
|
data/set.gemspec
ADDED
@@ -0,0 +1,24 @@
|
|
1
|
+
Gem::Specification.new do |spec|
|
2
|
+
spec.name = "set"
|
3
|
+
spec.version = "0.1.0"
|
4
|
+
spec.authors = ["Akinori MUSHA"]
|
5
|
+
spec.email = ["knu@idaemons.org"]
|
6
|
+
|
7
|
+
spec.summary = %q{Provides a class to deal with collections of unordered, unique values}
|
8
|
+
spec.description = %q{Provides a class to deal with collections of unordered, unique values}
|
9
|
+
spec.homepage = "https://github.com/ruby/set"
|
10
|
+
spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
|
11
|
+
spec.licenses = ["Ruby", "BSD-2-Clause"]
|
12
|
+
|
13
|
+
spec.metadata["homepage_uri"] = spec.homepage
|
14
|
+
spec.metadata["source_code_uri"] = spec.homepage
|
15
|
+
|
16
|
+
# Specify which files should be added to the gem when it is released.
|
17
|
+
# The `git ls-files -z` loads the files in the RubyGem that have been added into git.
|
18
|
+
spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
|
19
|
+
`git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
|
20
|
+
end
|
21
|
+
spec.bindir = "exe"
|
22
|
+
spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
|
23
|
+
spec.require_paths = ["lib"]
|
24
|
+
end
|
metadata
ADDED
@@ -0,0 +1,56 @@
|
|
1
|
+
--- !ruby/object:Gem::Specification
|
2
|
+
name: set
|
3
|
+
version: !ruby/object:Gem::Version
|
4
|
+
version: 0.1.0
|
5
|
+
platform: ruby
|
6
|
+
authors:
|
7
|
+
- Akinori MUSHA
|
8
|
+
autorequire:
|
9
|
+
bindir: exe
|
10
|
+
cert_chain: []
|
11
|
+
date: 2020-09-18 00:00:00.000000000 Z
|
12
|
+
dependencies: []
|
13
|
+
description: Provides a class to deal with collections of unordered, unique values
|
14
|
+
email:
|
15
|
+
- knu@idaemons.org
|
16
|
+
executables: []
|
17
|
+
extensions: []
|
18
|
+
extra_rdoc_files: []
|
19
|
+
files:
|
20
|
+
- ".github/workflows/test.yml"
|
21
|
+
- ".gitignore"
|
22
|
+
- Gemfile
|
23
|
+
- LICENSE.txt
|
24
|
+
- README.md
|
25
|
+
- Rakefile
|
26
|
+
- bin/console
|
27
|
+
- bin/setup
|
28
|
+
- lib/set.rb
|
29
|
+
- set.gemspec
|
30
|
+
homepage: https://github.com/ruby/set
|
31
|
+
licenses:
|
32
|
+
- Ruby
|
33
|
+
- BSD-2-Clause
|
34
|
+
metadata:
|
35
|
+
homepage_uri: https://github.com/ruby/set
|
36
|
+
source_code_uri: https://github.com/ruby/set
|
37
|
+
post_install_message:
|
38
|
+
rdoc_options: []
|
39
|
+
require_paths:
|
40
|
+
- lib
|
41
|
+
required_ruby_version: !ruby/object:Gem::Requirement
|
42
|
+
requirements:
|
43
|
+
- - ">="
|
44
|
+
- !ruby/object:Gem::Version
|
45
|
+
version: 2.3.0
|
46
|
+
required_rubygems_version: !ruby/object:Gem::Requirement
|
47
|
+
requirements:
|
48
|
+
- - ">="
|
49
|
+
- !ruby/object:Gem::Version
|
50
|
+
version: '0'
|
51
|
+
requirements: []
|
52
|
+
rubygems_version: 3.2.0.rc.1
|
53
|
+
signing_key:
|
54
|
+
specification_version: 4
|
55
|
+
summary: Provides a class to deal with collections of unordered, unique values
|
56
|
+
test_files: []
|