style: align the spec style

update rubocop-config-crystal
add rubocop-rspec
fix README.md

Author: initdc

.rubocop.yml

@@ -1,8 +1,18 @@
 inherit_gem:
   rubocop-config-crystal: .rubocop.yml
 
+plugins:
+  - rubocop-rspec
+
 Metrics/BlockLength:
   Enabled: false
 
-Style/MethodCallWithArgsParentheses:
-  Enabled: true
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MissingExpectationTargetMethod:
+  Enabled: false
+

Gemfile

@@ -13,4 +13,6 @@ gem "rspec", "~> 3.0"
 
 gem "rubocop", "~> 1.21"
 
-gem "rubocop-config-crystal"
+gem "rubocop-config-crystal", "~> 0.0.2"
+
+gem "rubocop-rspec", require: false

Gemfile.lock

@@ -47,7 +47,10 @@ GEM
     rubocop-ast (1.47.1)
       parser (>= 3.3.7.2)
       prism (~> 1.4)
-    rubocop-config-crystal (0.0.1)
+    rubocop-config-crystal (0.0.2)
+    rubocop-rspec (3.7.0)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.72, >= 1.72.1)
     ruby-progressbar (1.13.0)
     unicode-display_width (3.2.0)
       unicode-emoji (~> 4.1)
@@ -62,7 +65,8 @@ DEPENDENCIES
   rs-result!
   rspec (~> 3.0)
   rubocop (~> 1.21)
-  rubocop-config-crystal
+  rubocop-config-crystal (~> 0.0.2)
+  rubocop-rspec
 
 BUNDLED WITH
    2.4.22

README.md

@@ -31,4 +31,4 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rs-result.
+Bug reports and pull requests are welcome on GitHub at https://github.com/initdc/rs-result.

Rakefile

@@ -4,9 +4,10 @@ require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
-
 require "rubocop/rake_task"
 
-RuboCop::RakeTask.new
+RuboCop::RakeTask.new do |task|
+  task.plugins << "rubocop-rspec"
+end
 
 task default: [:spec, :rubocop]

spec/rs/option_spec.rb

@@ -1,88 +1,88 @@
 # frozen_string_literal: true
 
-RSpec.describe(Rs::Option) do
+RSpec.describe Rs::Option do
   # https://doc.rust-lang.org/std/option/enum.Option.html
 
   it "new" do
-    expect { Some.new(nil) }.to(raise_error(Rs::Option::ArgumentError, "Some value cannot be nil"))
+    expect { Some.new(nil) }.to raise_error Rs::Option::ArgumentError, "Some value cannot be nil"
   end
 
   it "some?" do
     x = Some.new(2)
-    expect(x.some?).to(be(true))
+    expect(x.some?).to be true
 
     x = None.new
-    expect(x.some?).to(be(false))
+    expect(x.some?).to be false
   end
 
   it "some_and proc" do
     x = Some.new(2)
-    expect(x.some_and).to(be(true))
-    expect(x.some_and { |x| x > 1 }).to(be(true))
+    expect(x.some_and).to be true
+    expect(x.some_and { |x| x > 1 }).to be true
 
     x = Some.new(0)
-    expect(x.some_and { |x| x > 1 }).to(be(false))
+    expect(x.some_and { |x| x > 1 }).to be false
 
     x = None.new
-    expect(x.some_and { |x| x.to_i > 1 }).to(be(false))
+    expect(x.some_and { |x| x.to_i > 1 }).to be false
 
     x = Some.new("str")
-    expect(x.some_and { |x| x.size > 1 }).to(be(true))
+    expect(x.some_and { |x| x.size > 1 }).to be true
   end
 
   it "none?" do
     x = Some.new(2)
-    expect(x.none?).to(be(false))
+    expect(x.none?).to be false
 
     x = None.new
-    expect(x.none?).to(be(true))
+    expect(x.none?).to be true
   end
 
   it "none_or proc" do
     x = Some.new(2)
-    expect(x.none_or).to(be(false))
-    expect(x.none_or { |x| x > 1 }).to(be(true))
+    expect(x.none_or).to be false
+    expect(x.none_or { |x| x > 1 }).to be true
 
     x = Some.new(0)
-    expect(x.none_or { |x| x > 1 }).to(be(false))
+    expect(x.none_or { |x| x > 1 }).to be false
 
     x = None.new
-    expect(x.none_or { |x| x.to_i > 1 }).to(be(true))
+    expect(x.none_or { |x| x.to_i > 1 }).to be true
 
     x = Some.new("str")
-    expect(x.none_or { |x| x.size > 1 }).to(be(true))
+    expect(x.none_or { |x| x.size > 1 }).to be true
   end
 
   it "unwrap" do
     x = Some.new("air")
-    expect(x.unwrap).to(eq("air"))
+    expect(x.unwrap).to eq "air"
 
     x = None.new
-    expect { x.unwrap }.to(raise_error(Rs::Option::UnwrapNone))
+    expect { x.unwrap }.to raise_error Rs::Option::UnwrapNone
   end
 
   it "unwrap_or" do
-    expect(Some.new("car").unwrap_or("bike")).to(eq("car"))
-    expect(None.new.unwrap_or("bike")).to(eq("bike"))
+    expect(Some.new("car").unwrap_or("bike")).to eq "car"
+    expect(None.new.unwrap_or("bike")).to eq "bike"
   end
 
   it "unwrap_or proc" do
     k = 10
-    expect(Some.new(4).unwrap_or { 2 * k }).to(eq(4))
-    expect(None.new.unwrap_or { 2 * k }).to(eq(20))
+    expect(Some.new(4).unwrap_or { 2 * k }).to eq 4
+    expect(None.new.unwrap_or { 2 * k }).to eq 20
   end
 
   it "unwrap_or_else proc" do
     k = 10
-    expect(Some.new(4).unwrap_or_else { 2 * k }).to(eq(4))
-    expect(None.new.unwrap_or_else { 2 * k }).to(eq(20))
+    expect(Some.new(4).unwrap_or_else { 2 * k }).to eq 4
+    expect(None.new.unwrap_or_else { 2 * k }).to eq 20
   end
 
   it "unwrap_or default" do
     x = None.new
     y = Some.new(12)
 
-    expect(x.unwrap_or).to(eq(nil))
-    expect(y.unwrap_or).to(eq(12))
+    expect(x.unwrap_or).to be_nil
+    expect(y.unwrap_or).to eq 12
   end
 end

spec/rs/result_spec.rb

@@ -4,57 +4,57 @@
   # https://doc.rust-lang.org/std/result/enum.Result.html
 
   it "has a version number" do
-    expect(Rs::Result::VERSION).not_to(be(nil))
+    expect(Rs::Result::VERSION).not_to be_nil
   end
 
   it "ok?" do
     x = Ok.new(-3)
-    expect(x.ok?).to(be(true))
+    expect(x.ok?).to be true
 
     x = Err.new("Some error message")
-    expect(x.ok?).to(be(false))
+    expect(x.ok?).to be false
   end
 
   it "ok_and" do
     x = Ok.new(2)
-    expect(x.ok_and { |x| x > 1 }).to(be(true))
+    expect(x.ok_and { |x| x > 1 }).to be true
 
     x = Ok.new(0)
-    expect(x.ok_and { |x| x > 1 }).to(be(false))
+    expect(x.ok_and { |x| x > 1 }).to be false
 
     x = Err.new("hey")
-    expect(x.ok_and { |x| x > 1 }).to(be(false))
+    expect(x.ok_and { |x| x > 1 }).to be false
 
     x = Ok.new("str")
-    expect(x.ok_and { |x| x.size > 1 }).to(be(true))
+    expect(x.ok_and { |x| x.size > 1 }).to be true
   end
 
   it "err?" do
     x = Ok.new(-3)
-    expect(x.err?).to(be(false))
+    expect(x.err?).to be false
 
     x = Err.new("Some error message")
-    expect(x.err?).to(be(true))
+    expect(x.err?).to be true
   end
 
   it "err_and" do
     x = Err.new(Errno::ENOENT)
-    expect(x.err_and { |x| x == Errno::ENOENT }).to(be(true))
+    expect(x.err_and { |x| x == Errno::ENOENT }).to be true
 
     x = Err.new(Errno::EACCES)
-    expect(x.err_and { |x| x == Errno::ENOENT }).to(be(false))
+    expect(x.err_and { |x| x == Errno::ENOENT }).to be false
 
     x = Ok.new(123)
-    expect(x.err_and { |x| x == Errno::ENOENT }).to(be(false))
+    expect(x.err_and { |x| x == Errno::ENOENT }).to be false
 
     x = Err.new("str")
-    expect(x.err_and { |x| x.size > 1 }).to(be(true))
+    expect(x.err_and { |x| x.size > 1 }).to be true
   end
 
   it "ok" do
     x = Ok.new(2)
     expect(x.ok).is_a?(Some)
-    expect(x.unwrap).to(eq(2))
+    expect(x.unwrap).to eq 2
 
     x = Err.new("Nothing here")
     expect(x.ok).is_a?(None)
@@ -66,22 +66,22 @@
 
     x = Err.new("Nothing here")
     expect(x.err).is_a?(Some)
-    expect(x.unwrap_err).to(eq("Nothing here"))
+    expect(x.unwrap_err).to eq "Nothing here"
   end
 
   it "expect" do
     x = Err.new("emergency failure")
-    expect { x.expect("Testing expect") }.to(raise_error(Rs::Result::UnwrapOnErr, "Testing expect: emergency failure"))
+    expect { x.expect("Testing expect") }.to raise_error Rs::Result::UnwrapOnErr, "Testing expect: emergency failure"
   end
 
   it "unwrap" do
     x = Ok.new(2)
-    expect(x.unwrap).to(eq(2))
+    expect(x.unwrap).to eq 2
 
     x = Err.new("emergency failure")
     expect {
       x.unwrap
-    }.to(raise_error(Rs::Result::UnwrapOnErr, "called `Result::unwrap()` on an `Err` value: emergency failure"))
+    }.to raise_error Rs::Result::UnwrapOnErr, "called `Result::unwrap()` on an `Err` value: emergency failure"
   end
 
   it "unwrap_or default" do
@@ -101,36 +101,36 @@ def parse_year(str)
     good_year = parse_year(good_year_from_input).unwrap_or(0)
     bad_year = parse_year(bad_year_from_input).unwrap_or(0)
 
-    expect(good_year).to(eq(1909))
-    expect(bad_year).to(eq(0))
+    expect(good_year).to eq 1909
+    expect(bad_year).to eq 0
   end
 
   it "expect_err" do
     x = Ok.new(10)
-    expect { x.expect_err("Testing expect_err") }.to(raise_error(Rs::Result::UnwrapErrOnOk, "Testing expect_err: 10"))
+    expect { x.expect_err("Testing expect_err") }.to raise_error Rs::Result::UnwrapErrOnOk, "Testing expect_err: 10"
   end
 
   it "unwrap_err" do
     x = Ok.new(2)
     expect {
       x.unwrap_err
-    }.to(raise_error(Rs::Result::UnwrapErrOnOk, "called `Result::unwrap_err()` on an `Ok` value: 2"))
+    }.to raise_error Rs::Result::UnwrapErrOnOk, "called `Result::unwrap_err()` on an `Ok` value: 2"
 
     x = Err.new("emergency failure")
-    expect(x.unwrap_err).to(eq("emergency failure"))
+    expect(x.unwrap_err).to eq "emergency failure"
   end
 
   it "unwrap_or" do
     default = 2
     x = Ok.new(9)
-    expect(x.unwrap_or(default)).to(eq(9))
+    expect(x.unwrap_or(default)).to eq 9
 
     x = Err.new("error")
-    expect(x.unwrap_or(default)).to(eq(default))
+    expect(x.unwrap_or(default)).to eq default
   end
 
   it "unwrap_or_else" do
-    expect(Ok.new(2).unwrap_or_else { |x| x.size }).to(eq(2))
-    expect(Err.new("foo").unwrap_or_else { |x| x.size }).to(eq(3))
+    expect(Ok.new(2).unwrap_or_else { |x| x.size }).to eq 2
+    expect(Err.new("foo").unwrap_or_else { |x| x.size }).to eq 3
   end
 end