fear 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27594ab99bc8a361057d1222bd4e70aa49f5c8535c95f622f338ab17e216cd31
-  data.tar.gz: dfbd5982e2da247cdb74edb7a218023195c4806d56af786098e294165bf345ec
+  metadata.gz: df922b21ff9dcd7919c83d864ed99d7cc6cdd1618fac27f98f768c8cc921e569
+  data.tar.gz: 600968bd95a016565e58b782a877ea76b73eec925f1d637539b866acea6313fd
 SHA512:
-  metadata.gz: 4c880fdc1a916306cd222bb4d63526aa3b9ab19eadb095df1ea2aef4343e443015b8067628a34a0b436dc5d994f39fd8810b03dbb05adc7d6df975eb1943bee7
-  data.tar.gz: f9e9c441b5d208b65cbd678ae38412d404879834e1ca3ac6636140aa9b53bbb6c1ddf88b613c52d74cb6b09c481a0983c5a3e903c19ee5f98ca94161eb541ba9
+  metadata.gz: 99b517ac8c12f8071cba9324a68b0161ff4d3cc23e9230cf686b766c084500a9e0541f66b174b8bdebf063b1307adae9ac56806895aa5c8fabbad3c6c2b2a666
+  data.tar.gz: 0d91fec31fd44c59dbdb373bc230cd0d227a41b091ce3188fab59424d9ee86e7b7f3256f5b471a477dc96e5028d2bfa263bdc57b45cb6e4de3147dd71ef12d87

data/.github/dependabot.yml

@@ -0,0 +1,27 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "02:00"
+  open-pull-requests-limit: 10
+  ignore:
+  - dependency-name: dry-matcher
+    versions:
+    - "> 0.8.0"
+  - dependency-name: dry-monads
+    versions:
+    - "> 1.2.0"
+  - dependency-name: irb
+    versions:
+    - "> 1.1.0"
+  - dependency-name: rubocop-rspec
+    versions:
+    - "> 1.34.0"
+  - dependency-name: dry-types
+    versions:
+    - 1.5.0
+  - dependency-name: concurrent-ruby
+    versions:
+    - 1.1.8

data/.github/workflows/rubocop.yml

@@ -1,7 +1,7 @@
 # pulled from repo
 name: "Rubocop"
 
-on: push
+on: pull_request
 
 jobs:
   rubocop:
@@ -18,7 +18,7 @@ jobs:
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 2.6
+          ruby-version: 3.1
 
       # This step is not necessary if you add the gem to your Gemfile
       - name: Install Code Scanning integration

data/.github/workflows/spec.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: [ '2.5.x', '2.6.x', '2.7.x' ]
+        ruby: ['2.7.x' , '3.0.x', '3.1.x']
     name: ${{ matrix.ruby }}
 
     steps:

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 2.0.0
+
+* Added `Fear::Option#present?` and `Fear::Option#empty?` methods ([@Lokideos][])
+* Start testing against Ruby 3.1.0 ([@bolshakov][]) 
+* Minimal supported Ruby version is 2.7.0 ([@bolshakov][]) 
+* Make future and promises compatible with Ruby 3.0 method syntax. ([@bolshakov][]) 
+* Get rid off autoload in favor of require. Autoload appeared to be not thread-safe. ([@bolshakov][]) 
+* All monads are shareable with Ractors ([@bolshakov][]) 
+* Drop pattern extraction support (`Fear.xcase`). ([@bolshakov][]) 
+* Add top-level factory methods: `Fear::Some`, `Fear::Option`, `Fear::Right`, `Fear::Left` ([@bolshakov][]) 
+  `Fear::Try`, `Fear::Success`, and `Fear::Failure`. ([@bolshakov][]) 
+   
 ## 1.2.0
 
 * Implement `Fear::Option#zip` and `Fear::Future#zip` with block argument ([@bolshakov][]) 
@@ -56,3 +68,4 @@
 * Added `Either#or_else` and `Option#or_else`. `Try#or_else` may accept only block ([@bolshakov][])
   
 [@bolshakov]: https://github.com/bolshakov
+[@Lokideos]: https://github.com/Lokideos

data/Gemfile.lock

@@ -8,45 +8,40 @@ GIT
 PATH
   remote: .
   specs:
-    fear (1.2.0)
-      lru_redux
-      treetop
+    fear (2.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     any (0.1.0)
-    ast (2.4.1)
-    benchmark-ips (2.8.3)
-    concurrent-ruby (1.1.7)
-    diff-lcs (1.4.4)
-    docile (1.3.2)
-    dry-configurable (0.11.6)
+    ast (2.4.2)
+    benchmark-ips (2.10.0)
+    concurrent-ruby (1.1.10)
+    diff-lcs (1.5.0)
+    docile (1.3.4)
+    dry-configurable (0.12.1)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 0.4, >= 0.4.7)
-      dry-equalizer (~> 0.2)
+      dry-core (~> 0.5, >= 0.5.0)
     dry-container (0.7.2)
       concurrent-ruby (~> 1.0)
       dry-configurable (~> 0.1, >= 0.1.3)
-    dry-core (0.4.9)
+    dry-core (0.5.0)
       concurrent-ruby (~> 1.0)
     dry-equalizer (0.3.0)
     dry-inflector (0.2.0)
-    dry-logic (1.0.6)
+    dry-logic (1.1.0)
       concurrent-ruby (~> 1.0)
-      dry-core (~> 0.2)
-      dry-equalizer (~> 0.2)
+      dry-core (~> 0.5, >= 0.5)
     dry-matcher (0.8.0)
       dry-core (>= 0.4.7)
-    dry-monads (1.2.0)
+    dry-monads (1.3.5)
       concurrent-ruby (~> 1.0)
       dry-core (~> 0.4, >= 0.4.4)
       dry-equalizer
-    dry-types (1.4.0)
+    dry-types (1.5.1)
       concurrent-ruby (~> 1.0)
       dry-container (~> 0.3)
-      dry-core (~> 0.4, >= 0.4.4)
-      dry-equalizer (~> 0.3)
+      dry-core (~> 0.5, >= 0.5)
       dry-inflector (~> 0.1, >= 0.1.2)
       dry-logic (~> 1.0, >= 1.0.2)
     fear-rspec (0.3.0)
@@ -54,54 +49,56 @@ GEM
       rspec (~> 3.0)
     irb (1.1.0)
       reline (>= 0.0.1)
-    lru_redux (1.1.0)
-    parallel (1.20.0)
-    parser (2.7.2.0)
+    json (2.6.2)
+    parallel (1.22.1)
+    parser (3.1.2.0)
       ast (~> 2.4.1)
-    polyglot (0.3.5)
-    rainbow (3.0.0)
-    rake (13.0.1)
-    regexp_parser (1.8.2)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.5.0)
     reline (0.0.7)
-    rexml (3.2.4)
-    rspec (3.10.0)
-      rspec-core (~> 3.10.0)
-      rspec-expectations (~> 3.10.0)
-      rspec-mocks (~> 3.10.0)
-    rspec-core (3.10.0)
-      rspec-support (~> 3.10.0)
-    rspec-expectations (3.10.0)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-mocks (3.10.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-support (3.10.0)
-    rubocop (1.0.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    rubocop (1.32.0)
+      json (~> 2.3)
       parallel (~> 1.10)
-      parser (>= 2.7.1.5)
+      parser (>= 3.1.0.0)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8)
-      rexml
-      rubocop-ast (>= 0.6.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.19.1, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 2.0)
-    rubocop-ast (1.1.1)
-      parser (>= 2.7.1.5)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.19.1)
+      parser (>= 3.1.1.0)
     rubocop-rspec (1.34.0)
       rubocop (>= 0.60.0)
-    ruby-progressbar (1.10.1)
-    ruby_coding_standard (0.3.0)
-      rubocop (~> 1.0.0)
-    simplecov (0.19.1)
+    ruby-progressbar (1.11.0)
+    ruby_coding_standard (0.4.0)
+      rubocop (~> 1.32.0)
+    simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov-lcov (0.8.0)
-    treetop (1.6.11)
-      polyglot (~> 0.3)
-    unicode-display_width (1.7.0)
-    yard (0.9.25)
+    simplecov_json_formatter (0.1.2)
+    unicode-display_width (2.2.0)
+    webrick (1.7.0)
+    yard (0.9.28)
+      webrick (~> 1.7.0)
 
 PLATFORMS
   ruby
@@ -119,7 +116,7 @@ DEPENDENCIES
   qo!
   rake (~> 13.0)
   rspec (~> 3.1)
-  rubocop (= 1.0.0)
+  rubocop (= 1.32.0)
   rubocop-rspec (= 1.34.0)
   ruby_coding_standard
   simplecov
@@ -127,4 +124,4 @@ DEPENDENCIES
   yard
 
 BUNDLED WITH
-   2.0.2
+   2.1.4

data/README.md

@@ -40,7 +40,7 @@ Represents optional (nullable) values. Instances of `Option` are either an insta
 The most idiomatic way to use an `Option` instance is to treat it as a collection
 
 ```ruby
-name = Fear.option(params[:name])
+name = Fear.option(params[:name]) 
 upper = name.map(&:strip).select { |n| n.length != 0 }.map(&:upcase)
 puts upper.get_or_else('')
 ```
@@ -51,9 +51,11 @@ having to check for the existence of a value.
 A less-idiomatic way to use `Option` values is via pattern matching
 
 ```ruby
-Fear.option(params[:name]).match do |m|
-  m.some { |name| name.strip.upcase }
-  m.none { 'No name value' }
+case Fear.option(params[:name])
+in Fear::Some(name) 
+  name.strip.upcase
+in Fear::None
+  'No name value'
 end
 ```
 
@@ -68,17 +70,15 @@ else
 end
 ```
 
-Alternatively, include `Fear::Option::Mixin` to use `Option()`, `Some()` and `None()` methods:
+Alternatively, you can use camel-case factory methods `Fear::Option()`, `Fear::Some()` and `Fear::None` methods:
 
 ```ruby
-include Fear::Option::Mixin 
+Fear::Option(42) #=> #<Fear::Some get=42>
+Fear::Option(nil) #=> #<Fear::None>
 
-Option(42) #=> #<Fear::Some get=42>
-Option(nil) #=> #<Fear::None>
-
-Some(42) #=> #<Fear::Some get=42>
-Some(nil) #=> #<Fear::Some get=nil>
-None() #=> #<Fear::None>
+Fear::Some(42) #=> #<Fear::Some get=42>
+Fear::Some(nil) #=> #<Fear::Some get=nil>
+Fear::None #=> #<Fear::None>
 ``` 
 
 #### Option#get_or_else
@@ -156,7 +156,7 @@ Returns self if it is nonempty and applying the predicate to this `Option`'s val
 return `None`.
 
 ```ruby
-Fear.some(42).select { |v| v > 40 } #=> Fear.success(21)
+Fear.some(42).select { |v| v > 40 } #=> Fear.some(42)
 Fear.some(42).select { |v| v < 40 } #=> None
 Fear.none.select { |v| v < 40 }   #=> None
 ```
@@ -196,6 +196,24 @@ Fear.some(42).empty? #=> false
 Fear.none.empty?   #=> true
 ```
 
+#### Option#blank?
+
+Returns `true` if the `Option` is `None`, `false` otherwise.
+
+```ruby
+Fear.some(42).blank? #=> false
+Fear.none.blank?   #=> true
+```
+
+#### Option#present?
+
+Returns `false` if the `Option` is `None`, `true` otherwise.
+
+```ruby
+Fear.some(42).present? #=> true
+Fear.none.present?   #=> false
+```
+
 #### Option#zip
 
 Returns a `Fear::Some` formed from this Option and another Option by combining the corresponding elements in a pair. 
@@ -228,19 +246,14 @@ dividend = Fear.try { Integer(params[:dividend]) }
 divisor = Fear.try { Integer(params[:divisor]) }
 problem = dividend.flat_map { |x| divisor.map { |y| x / y } }
 
-problem.match |m|
-  m.success do |result|
-    puts "Result of #{dividend.get} / #{divisor.get} is: #{result}"
-  end
-
-  m.failure(ZeroDivisionError) do
-    puts "Division by zero is not allowed"
-  end
-
-  m.failure do |exception|
-    puts "You entered something wrong. Try again"
-    puts "Info from the exception: #{exception.message}"
-  end
+case problem
+in Fear::Success(result)
+  puts "Result of #{dividend.get} / #{divisor.get} is: #{result}"
+in Fear::Failure(ZeroDivisionError)
+  puts "Division by zero is not allowed"
+in Fear::Failure(exception)
+  puts "You entered something wrong. Try again"
+  puts "Info from the exception: #{exception.message}"
 end
 ```
 
@@ -257,13 +270,11 @@ type of default behavior in the case of failure.
 *NOTE*: Only non-fatal exceptions are caught by the combinators on `Try`.
 Serious system errors, on the other hand, will be thrown.
 
-Alternatively, include `Fear::Try::Mixin` to use `Try()` method:
+Alternatively, include you can use camel-case factory method `Fear::Try()`:
 
 ```ruby
-include Fear::Try::Mixin 
-
-Try { 4/0 }  #=> #<Fear::Failure exception=...>
-Try { 4/2 }  #=> #<Fear::Success value=2>
+Fear::Try { 4/0 }  #=> #<Fear::Failure exception=...>
+Fear::Try { 4/2 }  #=> #<Fear::Success value=2>
 ```
 
 #### Try#get_or_else
@@ -318,7 +329,7 @@ Fear.failure(ArgumentError.new).flat_map { |v| Fear.success(v/2) } #=> Fear.fail
 Returns an `Some` containing the `Success` value or a `None` if this is a `Failure`.
 
 ```ruby
-Fear.success(42).to_option                 #=> Fear.some(21)
+Fear.success(42).to_option                 #=> Fear.some(42)
 Fear.failure(ArgumentError.new).to_option  #=> None
 ```
 
@@ -379,7 +390,7 @@ Converts this to a `Failure` if the predicate is not satisfied.
 
 ```ruby
 Fear.success(42).select { |v| v > 40 }
-  #=> Fear.success(21)
+  #=> Fear.success(42)
 Fear.success(42).select { |v| v < 40 }
   #=> Fear.failure(Fear::NoSuchElementError.new("Predicate does not hold for 42"))
 Fear.failure(ArgumentError.new).select { |v| v < 40 }
@@ -441,7 +452,7 @@ Fear.success(42).to_either                #=> Fear.right(42)
 Fear.failure(ArgumentError.new).to_either #=> Fear.left(ArgumentError.new)
 ```
 
-### Either ([API Documentation](https://www.rubydoc.info/github/bolshakov/fear/master/Fear/Option))
+### Either ([API Documentation](https://www.rubydoc.info/github/bolshakov/fear/master/Fear/Either))
   
 Represents a value of one of two possible types (a disjoint union.)
 An instance of `Either` is either an instance of `Left` or `Right`.
@@ -463,14 +474,11 @@ rescue ArgumentError
   Fear.left(in)
 end
 
-result.match do |m|
-  m.right do |x|
-    "You passed me the Int: #{x}, which I will increment. #{x} + 1 = #{x+1}"
-  end
-
-  m.left do |x|
-    "You passed me the String: #{x}"
-  end
+case result
+in Fear::Right(x)
+  "You passed me the Int: #{x}, which I will increment. #{x} + 1 = #{x+1}"
+in Fear::Left(x)
+  "You passed me the String: #{x}"
 end
 ```
 
@@ -478,13 +486,11 @@ Either is right-biased, which means that `Right` is assumed to be the default ca
 operate on. If it is `Left`, operations like `#map`, `#flat_map`, ... return the `Left` value
 unchanged.
 
-Alternatively, include `Fear::Either::Mixin` to use `Left()`, and `Right()` methods:
+Alternatively, you can use camel-case factory methods `Fear::Left()`, and `Fear::Right()`:
 
 ```ruby
-include Fear::Either::Mixin 
-
-Left(42)  #=> #<Fear::Left value=42>
-Right(42)  #=> #<Fear::Right value=42>
+Fear::Left(42)  #=> #<Fear::Left value=42>
+Fear::Right(42)  #=> #<Fear::Right value=42>
 ```
 
 #### Either#get_or_else
@@ -551,7 +557,7 @@ Fear.left('undefined').flat_map { |v| Fear.right(v/2) } #=> Fear.left('undefined
 Returns an `Some` containing the `Right` value or a `None` if this is a `Left`.
 
 ```ruby
-Fear.right(42).to_option          #=> Fear.some(21)
+Fear.right(42).to_option          #=> Fear.some(42)
 Fear.left('undefined').to_option  #=> Fear::None
 ```
 
@@ -963,144 +969,6 @@ matcher.(42) #=> "42 is a number"
 matcher.(10..20) #=> "10..20 is a Range"
 ``` 
 
-#### Pattern extraction 
-
-It's possible to use special syntax to match against an object and extract a variable form this object.
-To perform such extraction, `#xcase` method should be used. The following example should give you a sense 
-how extraction works.
-
-```ruby
-matcher = Fear.matcher do |m|
-  m.xcase('[1, *tail]') { |tail:| tail }
-end
-```
-
-It matches only on an array starting from `1` integer, and captures its tail:
-
-```ruby
-matcher.([1,2,3]) #=> [2,3]
-matcher.([2,3]) #=> raises MatchError
-``` 
-
-If you want to match against any value, use `_` 
-
-```ruby 
-matcher = Fear.matcher do |m|
-  m.xcase('[1, _, 3]') { .. }
-end
-```
-
-It matches against `[1, 2, 3]`, `[1, 'foo', 3]`, but not `[1, 2]`. It's also possible to capture several variables
-at the same time. Tho following example describes an array starting from `1`, and captures second and third elements.
-
-
-```ruby 
-matcher = Fear.matcher do |m|
-  m.xcase('[1, second, third]') { |second:, third: |.. }
-end
-``` 
-
-Matching on deeper structures is possible as well:
-
-```ruby 
-matcher = Fear.matcher do |m|
-  m.xcase('[["status", first_status], 4, *tail]') { |first_status:, tail: |.. }
-end
-``` 
-
-If you want to capture variable of specific type, there is a type matcher for that case:
-
-```ruby 
-matcher = Fear.matcher do |m|
-  m.xcase('[head : String, 2, *]') { |head: | head }
-end
-matcher.(['foo', 2]) #=> 'foo'
-matcher.(['foo', 3]) #=> MatchError
-matcher.([1, 2]) #=> MatchError
-``` 
-
-You can extract variables from more complex objects. Fear packed with extractors for monads and `Date` object:
-
-```ruby
-Fear.matcher do |m|
-  m.xcase('Date(year, 2, 29)', ->(year:) { year < 2000 }) do |year:|
-    "#{year} is a leap year before Millennium"
-  end
-  
-  m.xcase('Date(year, 2, 29)') do |year:|
-    "#{year} is a leap year after Millennium"
-  end
-  
-  m.case(Date) do |date|
-    "#{date.year} is not a leap year"
-  end
-end
-``` 
-
-This matcher extracts values from date object and match against them at the same time
-
-```ruby 
-matcher.(Date.new(1996,02,29)) #=> "1996 is a leap year before Millennium"
-matcher.(Date.new(2004,02,29)) #=> "1996 is a leap year after Millennium"
-matcher.(Date.new(2003,01,24)) #=> "2003 is not a leap year"
-```
-
-Nothing tricky here. The extractor object takes an object and tries to give back the arguments. It's like 
-constructor, but instead of construction an object, it deconstructs it. 
-
-An argument of an extractor may be also a pattern or even  introduce a new variable. 
-
-```ruby 
-matcher = Fear.matcher do |m|
-  m.xcase('Some([status : Integer, body : String])') do |status:, body:|
-    "#{body.bytesize} bytes received with code #{status}"
-  end 
-end
-
-matcher.(Fear.some([200, 'hello'])) #=> "5 bytes received with code 200"
-matcher.(Fear.some(['hello', 200])) #=> MatchError 
-```
-
-You can provide extractors for you own classes
-
-```ruby 
-Fear.register_extractor(User, Fear.case(User) { |user| [user.id, user.email] }.lift)
-# is the same as
-Fear.register_extractor(User, proc do |user|
-  if user.is_a?(User)
-    Fear.some([user.id, user.email])
-  else
-    Fear.none
-  end
-end)
-```
-
-Now extracting user's id and email is possible:
-
-
-```ruby 
-Fear.match(user) do |m|
-  m.xcase('User(id, email)') { |id:, email:| }
-end
-```
-
-Note, registered extractor should return either array of arguments, or boolean.
-
-#### Extracting struct
-
-There is predefined `Struct` extractor:
-
-```ruby
-Envelope = Struct.new(:id, :receiver, :sender, :message)
-
-Fear.matcher do |m|
-  m.xcase('envelope @ Envelope(id, _, sender, _)') do |id:, sender:, envelope:|
-    acknowledge(id, sender)
-    process(acknowledge)
-  end
-end
-```
-
 #### How to debug pattern extractors?
 
 You can build pattern manually and ask for failure reason:

data/Rakefile

@@ -198,27 +198,6 @@ namespace :perf do
       end
     end
 
-    task :qo_vs_fear_pattern_extraction do
-      User = Struct.new(:id, :name)
-      user = User.new(42, "Jane")
-
-      Benchmark.ips do |x|
-        x.report("Qo") do
-          Qo.case(user, destructure: true) do |m|
-            m.when(User) { |id, name| [id, name] }
-          end
-        end
-
-        x.report("Fear") do
-          Fear.match(user) do |m|
-            m.xcase("User(id, name)") { |id:, name:| [id, name] }
-          end
-        end
-
-        x.compare!
-      end
-    end
-
     task :dry_vs_qo_vs_fear_try do
       module ExhaustivePatternMatch
         def initialize(*)

data/examples/pattern_extracting.rb

@@ -4,11 +4,11 @@ require "fear"
 
 User = Struct.new(:id, :name, :admin)
 
-matcher = Fear.matcher do |m|
-  m.xcase("User(_, name, true)") do |name:|
+matcher = proc do |value|
+  case value
+  in User(admin: true, name:)
     puts "Hi #{name}, you are welcome"
-  end
-  m.xcase("User(_, _, false)") do
+  in User(admin: false)
     puts "Only admins are allowed here"
   end
 end

data/fear.gemspec

@@ -19,9 +19,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^bin\/}) { |f| File.basename(f) }
   spec.test_files = spec.files.grep(%r{^spec\/})
   spec.require_paths = ["lib"]
-
-  spec.add_runtime_dependency "lru_redux"
-  spec.add_runtime_dependency "treetop"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
   spec.add_development_dependency "benchmark-ips"
   spec.add_development_dependency "bundler"
@@ -32,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.1"
   spec.add_development_dependency "rubocop-rspec", "1.34.0"
-  spec.add_development_dependency "rubocop", "1.0.0"
+  spec.add_development_dependency "rubocop", "1.32.0"
   spec.add_development_dependency "ruby_coding_standard"
   spec.add_development_dependency "yard"
   spec.add_development_dependency "dry-types"