set 1.0.0 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9efb249e9dc58441358a2013c39ac9f9becd2de6728f107c1b5554935ffe0467
-  data.tar.gz: 8fe8e6f7a664ba006025b4b67ec80335093ef215e348481a44e12ee23b9e42d2
+  metadata.gz: e23398781865843cd7ba5286dca1a65ff241807ba8196020407b986bc74270b1
+  data.tar.gz: 19c57ed5aa898b0e4ee695df08aeccfb0d313cd785d4dd318941d5bb68291595
 SHA512:
-  metadata.gz: 76706c0faab6d07b44c213919862f779bf686eb70bd084cb7cbe0b7543de6aacd3c9146174ed4fa7954435c2739008267660c92fa8598890df64b0b9bb5d72e2
-  data.tar.gz: a86535d57dba0161abbbc04607ed41f6964fb101d0b236977508b0e7962796ac326911cae978f5035c9669bf2ec9564a5d4d52cad817fbd65276892485eecbda
+  metadata.gz: 88ee0f430a9b381d557f4c8bbe161c2199207ffcbaeb79d78daec9b9dc3e4ebb9fbc3a397ae82c5ffeba0b73782e9363ee19512e0b1b0372628ef4c6d715365a
+  data.tar.gz: d05a97bb9a5cb900eb303ce85926b73e04530fd44ca0cc85e9ca09e8413af5f5a3ad812cf4409a9fd5f2bc191632e8673d9fc3c89ebb62b8fa13fcf6a3c643ff

data/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'

data/.github/workflows/test.yml

@@ -11,14 +11,12 @@ jobs:
         os: [ ubuntu-latest, macos-latest ]
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@master
+    - uses: actions/checkout@v3
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
     - name: Install dependencies
-      run: |
-        gem install bundler --no-document
-        bundle install
+      run: bundle install
     - name: Run test
       run: rake test

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Set Changelog
 
-## 1.0.0 (2020-12-21)
+# 1.0.2 (2021-10-25)
+
+* Enhancements
+  * Allow Set#intersect? and #disjoint? to accept array argument \[[Feature #17838][]] [#18][] ([@jeremyevans][])
+  * Make Set#pretty_print IRB::ColorPrinter friendly [#17][] ([@k-tsj][])
+  * Improve documentation [#16][], [#20][] ([@BurdetteLamar][])
+  * Follow the license change in Ruby and add BSD-2-Clause
+
+# 1.0.1 (2020-12-22)
+
+* Enhancements
+  * Eliminate warnings
+
+# 1.0.0 (2020-12-21)
 
 This is the first release of set as a gem.  Here lists the changes since the version bundled with Ruby 2.7.
 
@@ -14,6 +27,14 @@ This is the first release of set as a gem.  Here lists the changes since the ver
 [#2]: https://github.com/ruby/set/pull/2
 [#4]: https://github.com/ruby/set/pull/4
 [#5]: https://github.com/ruby/set/pull/5
+[#16]: https://github.com/ruby/set/pull/16
+[#17]: https://github.com/ruby/set/pull/17
+[#18]: https://github.com/ruby/set/pull/18
+[#20]: https://github.com/ruby/set/pull/20
+[Feature #17838]: https://bugs.ruby-lang.org/issues/17838
 
+[@BurdetteLamar]: https://github.com/BurdetteLamar
+[@jeremyevans]: https://github.com/jeremyevans
+[@k-tsj]: https://github.com/k-tsj
 [@knu]: https://github.com/knu
 [@marcandre]: https://github.com/marcandre

data/README.md

@@ -1,8 +1,39 @@
 # Set
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/set`. To experiment with that code, run `bin/console` for an interactive prompt.
+This library provides the Set class, which deals with a collection of
+unordered values with no duplicates.  It is a hybrid of Array's
+intuitive inter-operation facilities and Hash's fast lookup.
 
-TODO: Delete this and the text above, and describe your gem
+The method `to_set` is added to Enumerable for convenience.
+
+Set implements a collection of unordered values with no duplicates.
+This is a hybrid of Array's intuitive inter-operation facilities and
+Hash's fast lookup.
+
+Set is easy to use with Enumerable objects (implementing `each`).
+Most of the initializer methods and binary operators accept generic
+Enumerable objects besides sets and arrays.  An Enumerable object can
+be converted to Set using the `to_set` method.
+
+Set uses Hash as storage, so you must note the following points:
+
+* Equality of elements is determined according to Object#eql? and
+  Object#hash.  Use Set#compare_by_identity to make a set compare its
+  elements by their identity.
+
+* Set assumes that the identity of each element does not change while
+  it is stored.  Modifying an element of a set will render the set to
+  an unreliable state.
+
+* When a string is to be stored, a frozen copy of the string is stored
+  instead unless the original string is already frozen.
+
+### Comparison
+
+The comparison operators `<`, `>`, `<=`, and `>=` are implemented as
+shorthand for the {proper_,}{subset?,superset?} methods.  The `<=>`
+operator reflects this order, or return `nil` for sets that both have
+distinct elements (`{x, y}` vs. `{x, z}` for example).
 
 ## Installation
 
@@ -37,8 +68,6 @@ s2.subset?(s1)                        #=> true
 
 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.
 
-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).
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/set.

data/lib/set/sorted_set.rb

@@ -1,6 +1,6 @@
 begin
   require 'sorted_set'
 rescue ::LoadError
-  raise "The `SortedSet` class has been extracted from the `set` library." \
+  raise "The `SortedSet` class has been extracted from the `set` library. " \
         "You must use the `sorted_set` gem or other alternatives."
 end

data/lib/set.rb

@@ -1,35 +1,31 @@
-#--
 # frozen_string_literal: true
+# :markup: markdown
 #
 # set.rb - defines the Set class
-#++
-# Copyright (c) 2002-2016 Akinori MUSHA <knu@iDaemons.org>
+#
+# Copyright (c) 2002-2020 Akinori MUSHA <knu@iDaemons.org>
 #
 # Documentation by Akinori MUSHA and Gavin Sinclair.
 #
 # All rights reserved.  You can redistribute and/or modify it under the same
 # terms as Ruby.
-#
-#   $Id$
-#
-# == Overview
-#
+
+
+##
 # This library provides the Set class, which deals with a collection
 # of unordered values with no duplicates.  It is a hybrid of Array's
 # intuitive inter-operation facilities and Hash's fast lookup.
 #
-# The method +to_set+ is added to Enumerable for convenience.
-
-
+# The method `to_set` is added to Enumerable for convenience.
 #
 # Set implements a collection of unordered values with no duplicates.
 # This is a hybrid of Array's intuitive inter-operation facilities and
 # Hash's fast lookup.
 #
-# Set is easy to use with Enumerable objects (implementing +each+).
+# Set is easy to use with Enumerable objects (implementing `each`).
 # Most of the initializer methods and binary operators accept generic
 # Enumerable objects besides sets and arrays.  An Enumerable object
-# can be converted to Set using the +to_set+ method.
+# can be converted to Set using the `to_set` method.
 #
 # Set uses Hash as storage, so you must note the following points:
 #
@@ -42,27 +38,186 @@
 # * When a string is to be stored, a frozen copy of the string is
 #   stored instead unless the original string is already frozen.
 #
-# == Comparison
+# ## Comparison
+#
+# The comparison operators `<`, `>`, `<=`, and `>=` are implemented as
+# shorthand for the {proper_,}{subset?,superset?} methods.  The `<=>`
+# operator reflects this order, or return `nil` for sets that both
+# have distinct elements (`{x, y}` vs. `{x, z}` for example).
+#
+# ## Example
+#
+# ```ruby
+# require 'set'
+# s1 = Set[1, 2]                        #=> #<Set: {1, 2}>
+# s2 = [1, 2].to_set                    #=> #<Set: {1, 2}>
+# s1 == s2                              #=> true
+# s1.add("foo")                         #=> #<Set: {1, 2, "foo"}>
+# s1.merge([2, 6])                      #=> #<Set: {1, 2, "foo", 6}>
+# s1.subset?(s2)                        #=> false
+# s2.subset?(s1)                        #=> true
+# ```
+#
+# ## Contact
+#
+# - Akinori MUSHA <<knu@iDaemons.org>> (current maintainer)
+#
+# ## What's Here
+#
+#  First, what's elsewhere. \Class \Set:
+#
+# - Inherits from {class Object}[https://docs.ruby-lang.org/en/master/Object.html#class-Object-label-What-27s+Here].
+# - Includes {module Enumerable}[https://docs.ruby-lang.org/en/master/Enumerable.html#module-Enumerable-label-What-27s+Here],
+#   which provides dozens of additional methods.
+#
+# In particular, class \Set does not have many methods of its own
+# for fetching or for iterating.
+# Instead, it relies on those in \Enumerable.
+#
+# Here, class \Set provides methods that are useful for:
+#
+# - [Creating a Set](#class-Set-label-Methods+for+Creating+a+Set)
+# - [Set Operations](#class-Set-label-Methods+for+Set+Operations)
+# - [Comparing](#class-Set-label-Methods+for+Comparing)
+# - [Querying](#class-Set-label-Methods+for+Querying)
+# - [Assigning](#class-Set-label-Methods+for+Assigning)
+# - [Deleting](#class-Set-label-Methods+for+Deleting)
+# - [Converting](#class-Set-label-Methods+for+Converting)
+# - [Iterating](#class-Set-label-Methods+for+Iterating)
+# - [And more....](#class-Set-label-Other+Methods)
 #
-# The comparison operators <, >, <=, and >= are implemented as
-# shorthand for the {proper_,}{subset?,superset?} methods.
-# The <=> operator reflects this order, or return `nil` for
-# sets that both have distinct elements ({x, y} vs. {x, z} for example).
+# ### Methods for Creating a \Set
 #
-# == Example
+# - ::[]:
+#   Returns a new set containing the given objects.
+# - ::new:
+#   Returns a new set containing either the given objects
+#   (if no block given) or the return values from the called block
+#   (if a block given).
 #
-#   require 'set'
-#   s1 = Set[1, 2]                        #=> #<Set: {1, 2}>
-#   s2 = [1, 2].to_set                    #=> #<Set: {1, 2}>
-#   s1 == s2                              #=> true
-#   s1.add("foo")                         #=> #<Set: {1, 2, "foo"}>
-#   s1.merge([2, 6])                      #=> #<Set: {1, 2, "foo", 6}>
-#   s1.subset?(s2)                        #=> false
-#   s2.subset?(s1)                        #=> true
+# ### Methods for \Set Operations
 #
-# == Contact
+# - [|](#method-i-7C) (aliased as #union and #+):
+#   Returns a new set containing all elements from +self+
+#   and all elements from a given enumerable (no duplicates).
+# - [&](#method-i-26) (aliased as #intersection):
+#   Returns a new set containing all elements common to +self+
+#   and a given enumerable.
+# - [-](#method-i-2D) (aliased as #difference):
+#   Returns a copy of +self+ with all elements
+#   in a given enumerable removed.
+# - [\^](#method-i-5E):
+#   Returns a new set containing all elements from +self+
+#   and a given enumerable except those common to both.
 #
-#   - Akinori MUSHA <knu@iDaemons.org> (current maintainer)
+# ### Methods for Comparing
+#
+# - [<=>](#method-i-3C-3D-3E):
+#   Returns -1, 0, or 1 as +self+ is less than, equal to,
+#   or greater than a given object.
+# - [==](#method-i-3D-3D):
+#   Returns whether +self+ and a given enumerable are equal,
+#   as determined by Object#eql?.
+# - \#compare_by_identity?:
+#   Returns whether the set considers only identity
+#   when comparing elements.
+#
+# ### Methods for Querying
+#
+# - \#length (aliased as #size):
+#   Returns the count of elements.
+# - \#empty?:
+#   Returns whether the set has no elements.
+# - \#include? (aliased as #member? and #===):
+#   Returns whether a given object is an element in the set.
+# - \#subset? (aliased as [<=](#method-i-3C-3D)):
+#   Returns whether a given object is a subset of the set.
+# - \#proper_subset? (aliased as [<](#method-i-3C)):
+#   Returns whether a given enumerable is a proper subset of the set.
+# - \#superset? (aliased as [>=](#method-i-3E-3D])):
+#   Returns whether a given enumerable is a superset of the set.
+# - \#proper_superset? (aliased as [>](#method-i-3E)):
+#   Returns whether a given enumerable is a proper superset of the set.
+# - \#disjoint?:
+#   Returns +true+ if the set and a given enumerable
+#   have no common elements, +false+ otherwise.
+# - \#intersect?:
+#   Returns +true+ if the set and a given enumerable:
+#   have any common elements, +false+ otherwise.
+# - \#compare_by_identity?:
+#   Returns whether the set considers only identity
+#   when comparing elements.
+#
+# ### Methods for Assigning
+#
+# - \#add (aliased as #<<):
+#   Adds a given object to the set; returns +self+.
+# - \#add?:
+#   If the given object is not an element in the set,
+#   adds it and returns +self+; otherwise, returns +nil+.
+# - \#merge:
+#   Adds each given object to the set; returns +self+.
+# - \#replace:
+#   Replaces the contents of the set with the contents
+#   of a given enumerable.
+#
+# ### Methods for Deleting
+#
+# - \#clear:
+#   Removes all elements in the set; returns +self+.
+# - \#delete:
+#   Removes a given object from the set; returns +self+.
+# - \#delete?:
+#   If the given object is an element in the set,
+#   removes it and returns +self+; otherwise, returns +nil+.
+# - \#subtract:
+#   Removes each given object from the set; returns +self+.
+# - \#delete_if - Removes elements specified by a given block.
+# - \#select! (aliased as #filter!):
+#   Removes elements not specified by a given block.
+# - \#keep_if:
+#   Removes elements not specified by a given block.
+# - \#reject!
+#   Removes elements specified by a given block.
+#
+# ### Methods for Converting
+#
+# - \#classify:
+#   Returns a hash that classifies the elements,
+#   as determined by the given block.
+# - \#collect! (aliased as #map!):
+#   Replaces each element with a block return-value.
+# - \#divide:
+#   Returns a hash that classifies the elements,
+#   as determined by the given block;
+#   differs from #classify in that the block may accept
+#   either one or two arguments.
+# - \#flatten:
+#   Returns a new set that is a recursive flattening of +self+.
+#  \#flatten!:
+#   Replaces each nested set in +self+ with the elements from that set.
+# - \#inspect (aliased as #to_s):
+#   Returns a string displaying the elements.
+# - \#join:
+#   Returns a string containing all elements, converted to strings
+#   as needed, and joined by the given record separator.
+# - \#to_a:
+#   Returns an array containing all set elements.
+# - \#to_set:
+#   Returns +self+ if given no arguments and no block;
+#   with a block given, returns a new set consisting of block
+#   return values.
+#
+# ### Methods for Iterating
+#
+# - \#each:
+#   Calls the block with each successive element; returns +self+.
+#
+# ### Other Methods
+#
+# - \#reset:
+#   Resets the internal state; useful if an object
+#   has been modified while an element in the set.
 #
 class Set
   include Enumerable
@@ -199,9 +354,9 @@ class Set
   end
 
   # Returns self if no arguments are given.  Otherwise, converts the
-  # set to another with klass.new(self, *args, &block).
+  # set to another with `klass.new(self, *args, &block)`.
   #
-  # In subclasses, returns klass.new(self, *args, &block) unless
+  # In subclasses, returns `klass.new(self, *args, &block)` unless
   # overridden.
   def to_set(klass = Set, *args, &block)
     return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
@@ -315,25 +470,35 @@ class Set
     end
   end
 
-  # Returns true if the set and the given set have at least one
+  # Returns true if the set and the given enumerable have at least one
   # element in common.
   #
-  #   Set[1, 2, 3].intersect? Set[4, 5]   #=> false
-  #   Set[1, 2, 3].intersect? Set[3, 4]   #=> true
+  #     Set[1, 2, 3].intersect? Set[4, 5]   #=> false
+  #     Set[1, 2, 3].intersect? Set[3, 4]   #=> true
+  #     Set[1, 2, 3].intersect? 4..5        #=> false
+  #     Set[1, 2, 3].intersect? [3, 4]      #=> true
   def intersect?(set)
-    set.is_a?(Set) or raise ArgumentError, "value must be a set"
-    if size < set.size
-      any? { |o| set.include?(o) }
-    else
+    case set
+    when Set
+      if size < set.size
+        any? { |o| set.include?(o) }
+      else
+        set.any? { |o| include?(o) }
+      end
+    when Enumerable
       set.any? { |o| include?(o) }
+    else
+      raise ArgumentError, "value must be enumerable"
     end
   end
 
-  # Returns true if the set and the given set have no element in
-  # common.  This method is the opposite of +intersect?+.
+  # Returns true if the set and the given enumerable have
+  # no element in common.  This method is the opposite of `intersect?`.
   #
-  #   Set[1, 2, 3].disjoint? Set[3, 4]   #=> false
-  #   Set[1, 2, 3].disjoint? Set[4, 5]   #=> true
+  #     Set[1, 2, 3].disjoint? Set[3, 4]   #=> false
+  #     Set[1, 2, 3].disjoint? Set[4, 5]   #=> true
+  #     Set[1, 2, 3].disjoint? [3, 4]      #=> false
+  #     Set[1, 2, 3].disjoint? 4..5        #=> true
   def disjoint?(set)
     !intersect?(set)
   end
@@ -347,7 +512,7 @@ class Set
     self
   end
 
-  # Adds the given object to the set and returns self.  Use +merge+ to
+  # Adds the given object to the set and returns self.  Use `merge` to
   # add many elements at once.
   #
   #     Set[1, 2].add(3)                    #=> #<Set: {1, 2, 3}>
@@ -369,8 +534,8 @@ class Set
     add(o) unless include?(o)
   end
 
-  # Deletes the given object from the set and returns self.  Use +subtract+ to
-  # delete many items at once.
+  # Deletes the given object from the set and returns self.  Use
+  # `subtract` to delete many items at once.
   def delete(o)
     @hash.delete(o)
     self
@@ -404,7 +569,7 @@ class Set
     self
   end
 
-  # Replaces the elements with ones returned by collect().
+  # Replaces the elements with ones returned by `collect()`.
   # Returns an enumerator if no block is given.
   def collect!
     block_given? or return enum_for(__method__) { size }
@@ -496,8 +661,8 @@ class Set
   alias intersection &
 
   # Returns a new set containing elements exclusive between the set
-  # and the given enumerable object.  (set ^ enum) is equivalent to
-  # ((set | enum) - (set & enum)).
+  # and the given enumerable object.  `(set ^ enum)` is equivalent to
+  # `((set | enum) - (set & enum))`.
   #
   #     Set[1, 2] ^ Set[2, 3]                   #=> #<Set: {3, 1}>
   #     Set[1, 'b', 'c'] ^ ['b', 'd']           #=> #<Set: {"d", 1, "c"}>
@@ -553,20 +718,20 @@ class Set
   #
   # Used in case statements:
   #
-  #   require 'set'
+  #     require 'set'
   #
-  #   case :apple
-  #   when Set[:potato, :carrot]
-  #     "vegetable"
-  #   when Set[:apple, :banana]
-  #     "fruit"
-  #   end
-  #   # => "fruit"
+  #     case :apple
+  #     when Set[:potato, :carrot]
+  #       "vegetable"
+  #     when Set[:apple, :banana]
+  #       "fruit"
+  #     end
+  #     # => "fruit"
   #
   # Or by itself:
   #
-  #   Set[1, 2, 3] === 2   #=> true
-  #   Set[1, 2, 3] === 4   #=> false
+  #     Set[1, 2, 3] === 2   #=> true
+  #     Set[1, 2, 3] === 4   #=> false
   #
   alias === include?
 
@@ -575,12 +740,12 @@ class Set
   # called once for each element of the set, passing the element as
   # parameter.
   #
-  #   require 'set'
-  #   files = Set.new(Dir.glob("*.rb"))
-  #   hash = files.classify { |f| File.mtime(f).year }
-  #   hash       #=> {2000=>#<Set: {"a.rb", "b.rb"}>,
-  #              #    2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
-  #              #    2002=>#<Set: {"f.rb"}>}
+  #     require 'set'
+  #     files = Set.new(Dir.glob("*.rb"))
+  #     hash = files.classify { |f| File.mtime(f).year }
+  #     hash       #=> {2000=>#<Set: {"a.rb", "b.rb"}>,
+  #                #    2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
+  #                #    2002=>#<Set: {"f.rb"}>}
   #
   # Returns an enumerator if no block is given.
   def classify # :yields: o
@@ -602,13 +767,13 @@ class Set
   # if block.call(o1, o2) is true.  Otherwise, elements o1 and o2 are
   # in common if block.call(o1) == block.call(o2).
   #
-  #   require 'set'
-  #   numbers = Set[1, 3, 4, 6, 9, 10, 11]
-  #   set = numbers.divide { |i,j| (i - j).abs == 1 }
-  #   set        #=> #<Set: {#<Set: {1}>,
-  #              #           #<Set: {11, 9, 10}>,
-  #              #           #<Set: {3, 4}>,
-  #              #           #<Set: {6}>}>
+  #     require 'set'
+  #     numbers = Set[1, 3, 4, 6, 9, 10, 11]
+  #     set = numbers.divide { |i,j| (i - j).abs == 1 }
+  #     set        #=> #<Set: {#<Set: {1}>,
+  #                #           #<Set: {11, 9, 10}>,
+  #                #           #<Set: {3, 4}>,
+  #                #           #<Set: {6}>}>
   #
   # Returns an enumerator if no block is given.
   def divide(&func)
@@ -669,13 +834,14 @@ class Set
   alias to_s inspect
 
   def pretty_print(pp)  # :nodoc:
-    pp.text sprintf('#<%s: {', self.class.name)
-    pp.nest(1) {
-      pp.seplist(self) { |o|
-        pp.pp o
+    pp.group(1, sprintf('#<%s:', self.class.name), '>') {
+      pp.breakable
+      pp.group(1, '{', '}') {
+        pp.seplist(self) { |o|
+          pp.pp o
+        }
       }
     }
-    pp.text "}>"
   end
 
   def pretty_print_cycle(pp)    # :nodoc:
@@ -685,10 +851,10 @@ end
 
 module Enumerable
   # Makes a set from the enumerable object with given arguments.
-  # Needs to +require "set"+ to use this method.
+  # Needs to `require "set"` to use this method.
   def to_set(klass = Set, *args, &block)
     klass.new(self, *args, &block)
-  end
+  end unless method_defined?(:to_set)
 end
 
 autoload :SortedSet, "#{__dir__}/set/sorted_set"

data/set.gemspec

@@ -1,13 +1,13 @@
 Gem::Specification.new do |spec|
   spec.name          = "set"
-  spec.version       = "1.0.0"
+  spec.version       = "1.0.3"
   spec.authors       = ["Akinori MUSHA"]
   spec.email         = ["knu@idaemons.org"]
 
   spec.summary       = %q{Provides a class to deal with collections of unordered, unique values}
   spec.description   = %q{Provides a class to deal with collections of unordered, unique values}
   spec.homepage      = "https://github.com/ruby/set"
-  spec.license       = "BSD-2-Clause"
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
   spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
@@ -19,7 +19,5 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: set
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.3
 platform: ruby
 authors:
 - Akinori MUSHA
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2020-12-21 00:00:00.000000000 Z
+date: 2022-09-06 00:00:00.000000000 Z
 dependencies: []
 description: Provides a class to deal with collections of unordered, unique values
 email:
@@ -17,6 +17,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - CHANGELOG.md
@@ -31,11 +32,12 @@ files:
 - set.gemspec
 homepage: https://github.com/ruby/set
 licenses:
+- Ruby
 - BSD-2-Clause
 metadata:
   homepage_uri: https://github.com/ruby/set
   source_code_uri: https://github.com/ruby/set
-  changelog_uri: https://github.com/ruby/set/blob/v1.0.0/CHANGELOG.md
+  changelog_uri: https://github.com/ruby/set/blob/v1.0.3/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -51,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.1
+rubygems_version: 3.4.0.dev
 signing_key:
 specification_version: 4
 summary: Provides a class to deal with collections of unordered, unique values