bcrypt 3.1.7 → 3.1.12

checksums.yaml

@@ -1,7 +1,17 @@
---- 
-SHA512: 
-  metadata.gz: e9a27bd4544153b3e73771ddc6ee262227c7c666df2001028f0860b335810b3f01862d30c86c24d893fda4690298016c60f76accd467e95c9c9048945802d7b6
-  data.tar.gz: 1798cf7b86267393f52b54b31356aa6c54b9ad524d86b97354322b4ae9a032e472cd98fb4cd209ecf2372a7e55556b42173a0c2d16a7467d7cc4b2ef98343636
-SHA1: 
-  metadata.gz: d58ac651be05f4747ff8d8258d2fe0920e26f375
-  data.tar.gz: 8f7b7aad5c4c3f572dd172fac39fcd0de31012c5
+---
+!binary "U0hBMjU2":
+  metadata.gz: !binary |-
+    YjQwMDJlZTYyN2EzOTJhMzg3Y2YyMDgwYjZjYjdiOWRkNmNiZWRkYmMxNGVh
+    MzkyZDczMmIzOTNjYWMwNDI3ZQ==
+  data.tar.gz: !binary |-
+    MDdkNzlhOGZmYjNlNWMxODE3OTBhMmFiYWU3ZDFiNDA2N2M4YThhOWUxZTcy
+    YmEwZDE5ODg4ZWJhMjg5NWEzNg==
+SHA512:
+  metadata.gz: !binary |-
+    YWFlMDYxYzFjM2NlNjY5YzhkZmVmYWIxNGI5NzFkNDgzZTdkYmViNmU4Mjhm
+    NmEzYjhiMjRlODA1ZDc2ZTRjNDQ3ODg4NzM1ZWI0YzIwNjU1YTZkZjE4MmQ3
+    Nzc1Y2IzZGM3YmZhOWQxYjI4OTBkY2RmMTE3MWZhZDhkYTQ4ZDA=
+  data.tar.gz: !binary |-
+    Njc0ODJhZWE3YTMwNTNhYmRlYjllYWZkYzM1YTg5OTU5NTAwNWYyMzU4ZWM2
+    ZmRlZmYyZGJlYWQ3NzcxNjNkOTNkODI5YTY4MTM1ZDllZGVmOTJmODNiNmRl
+    ZWRjZjRjOGRmM2FiNTM5M2I3MDBiYWYwN2NkNGZkNjZkYzI4ZjE=

data/.gitignore

@@ -1,10 +1,9 @@
+doc
+pkg
+tmp
 *.o
 *.bundle
 *.so
 *.jar
-ext/mri/Makefile
-doc
-pkg
-*.class
-tmp/
 .DS_Store
+.rbenv-gemsets

data/.travis.yml

@@ -1,15 +1,21 @@
 language: ruby
+before_install:
+  - gem update --system
+  - gem install bundler
 rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
+  - 1.8
+  - 1.9
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
   - ruby-head
   - jruby-18mode
   - jruby-19mode
   - jruby-head
-  - rbx-2
-  - rbx
+  - rbx-3
   - ree
 script: bundle exec rake

data/CHANGELOG

@@ -70,3 +70,19 @@
 3.1.7  Feb 24 2014
   - Rebuild corrupt Java binary version of gem [GH #90]
   - The 2.1 support for Windows binaries alleged in 3.1.3 was a lie -- documentation removed
+
+3.1.8  Oct 23 2014
+  - Add support for Ruby 2.1 in compiled Windows binaries [GH #102]
+
+3.1.9  Oct 23 2014
+  - Rebuild corrupt binaries
+
+3.1.10 Jan 28 2015
+  - Fix issue with dumping a BCrypt::Password instance to YAML in Ruby 2.2 [GH #107 by @mattwildig]
+
+3.1.11 Mar 06 2016
+  - Add support for Ruby 2.2 in compiled Windows binaries
+
+3.1.12 May 16 2018
+  - Add support for Ruby 2.3, 2.4, and 2.5 in compiled Windows binaries
+  - Fix compatibility with libxcrypt [GH #164 by @besser82]

data/Gemfile.lock

@@ -1,27 +1,32 @@
 PATH
   remote: .
   specs:
-    bcrypt (3.1.7)
+    bcrypt (3.1.12)
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.2.5)
-    json (1.8.1)
-    json (1.8.1-java)
-    rake (10.1.0)
-    rake-compiler (0.9.2)
+    json (1.8.6)
+    json (1.8.6-java)
+    rake (10.4.2)
+    rake-compiler (0.9.5)
       rake
     rdoc (3.12.2)
       json (~> 1.4)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.7)
-    rspec-expectations (2.14.4)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.4)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
 
 PLATFORMS
   java
@@ -33,4 +38,7 @@ DEPENDENCIES
   bcrypt!
   rake-compiler (~> 0.9.2)
   rdoc (~> 3.12)
-  rspec
+  rspec (>= 3)
+
+BUNDLED WITH
+   1.16.1

data/README.md

@@ -30,8 +30,8 @@ re-hash those passwords. This vulnerability only affected the JRuby gem.
 The bcrypt gem is available on the following ruby platforms:
 
 * JRuby
-* RubyInstaller 1.8, 1.9, and 2.0 builds on win32
-* Any 1.8, 1.9, 2.0, or 2.1 ruby on a BSD/OSX/Linux system with a compiler
+* RubyInstaller 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, and 2.5 builds on Windows
+* Any 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, or 2.5 Ruby on a BSD/OS X/Linux system with a compiler
 
 ## How to use `bcrypt()` in your Rails application
 
@@ -40,69 +40,58 @@ The bcrypt gem is available on the following ruby platforms:
 implements a similar authentication strategy to the code below.
 
 ### The _User_ model
-
-    require 'bcrypt'
-
-    class User < ActiveRecord::Base
-      # users.password_hash in the database is a :string
-      include BCrypt
-
-      def password
-        @password ||= Password.new(password_hash)
-      end
-
-      def password=(new_password)
-        @password = Password.create(new_password)
-        self.password_hash = @password
-      end
-    end
-
+```ruby
+require 'bcrypt'
+
+class User < ActiveRecord::Base
+  # users.password_hash in the database is a :string
+  include BCrypt
+
+  def password
+    @password ||= Password.new(password_hash)
+  end
+
+  def password=(new_password)
+    @password = Password.create(new_password)
+    self.password_hash = @password
+  end
+end
+```
 ### Creating an account
-
-    def create
-      @user = User.new(params[:user])
-      @user.password = params[:password]
-      @user.save!
-    end
-
+```ruby
+def create
+  @user = User.new(params[:user])
+  @user.password = params[:password]
+  @user.save!
+end
+```
 ### Authenticating a user
-
-    def login
-      @user = User.find_by_email(params[:email])
-      if @user.password == params[:password]
-        give_token
-      else
-        redirect_to home_url
-      end
-    end
-
-### If a user forgets their password?
-
-    # assign them a random one and mail it to them, asking them to change it
-    def forgot_password
-      @user = User.find_by_email(params[:email])
-      random_password = Array.new(10).map { (65 + rand(58)).chr }.join
-      @user.password = random_password
-      @user.save!
-      Mailer.create_and_deliver_password_change(@user, random_password)
-    end
-
+```ruby
+def login
+  @user = User.find_by_email(params[:email])
+  if @user.password == params[:password]
+    give_token
+  else
+    redirect_to home_url
+  end
+end
+```
 ## How to use bcrypt-ruby in general
+```ruby
+require 'bcrypt'
 
-    require 'bcrypt'
-
-    my_password = BCrypt::Password.create("my password")
-      #=> "$2a$10$vI8aWBnW3fID.ZQ4/zo1G.q1lRps.9cGLcZEiGDMVr5yUP1KUOYTa"
-
-    my_password.version              #=> "2a"
-    my_password.cost                 #=> 10
-    my_password == "my password"     #=> true
-    my_password == "not my password" #=> false
+my_password = BCrypt::Password.create("my password")
+#=> "$2a$10$vI8aWBnW3fID.ZQ4/zo1G.q1lRps.9cGLcZEiGDMVr5yUP1KUOYTa"
 
-    my_password = BCrypt::Password.new("$2a$10$vI8aWBnW3fID.ZQ4/zo1G.q1lRps.9cGLcZEiGDMVr5yUP1KUOYTa")
-    my_password == "my password"     #=> true
-    my_password == "not my password" #=> false
+my_password.version              #=> "2a"
+my_password.cost                 #=> 10
+my_password == "my password"     #=> true
+my_password == "not my password" #=> false
 
+my_password = BCrypt::Password.new("$2a$10$vI8aWBnW3fID.ZQ4/zo1G.q1lRps.9cGLcZEiGDMVr5yUP1KUOYTa")
+my_password == "my password"     #=> true
+my_password == "not my password" #=> false
+```
 Check the rdocs for more details -- BCrypt, BCrypt::Password.
 
 ## How `bcrypt()` works
@@ -171,15 +160,15 @@ stateless authentication architecture (e.g., HTTP Basic Auth), you will want to
 server load and keep your request times down. This will lower the security provided you, but there are few alternatives.
 
 To change the default cost factor used by bcrypt-ruby, use `BCrypt::Engine.cost = new_value`:
-
-    BCrypt::Password.create('secret').cost
-      #=> 10, the default provided by bcrypt-ruby
-
-    # set a new default cost
-    BCrypt::Engine.cost = 8
-    BCrypt::Password.create('secret').cost
-      #=> 8
-
+```ruby
+BCrypt::Password.create('secret').cost
+  #=> 10, the default provided by bcrypt-ruby
+
+# set a new default cost
+BCrypt::Engine.cost = 8
+BCrypt::Password.create('secret').cost
+  #=> 8
+```
 The default cost can be overridden as needed by passing an options hash with a different cost:
 
     BCrypt::Password.create('secret', :cost => 6).cost  #=> 6

data/Rakefile

@@ -7,16 +7,23 @@ require 'rdoc/task'
 require 'benchmark'
 
 CLEAN.include(
-  "ext/mri/*.o",
-  "ext/mri/*.bundle",
-  "ext/mri/*.so",
-  "ext/jruby/bcrypt_jruby/*.class"
+  "tmp",
+  "lib/1.8",
+  "lib/1.9",
+  "lib/2.0",
+  "lib/2.1",
+  "lib/2.2",
+  "lib/2.3",
+  "lib/2.4",
+  "lib/2.5",
+  "lib/bcrypt_ext.jar",
+  "lib/bcrypt_ext.so"
 )
 CLOBBER.include(
-  "ext/mri/Makefile",
-  "doc/coverage",
+  "doc",
   "pkg"
 )
+
 GEMSPEC = Gem::Specification.load("bcrypt.gemspec")
 
 task :default => [:compile, :spec]
@@ -58,6 +65,23 @@ else
     ext.cross_compile = true
     ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
   end
+
+  ENV['RUBY_CC_VERSION'].to_s.split(':').each do |ruby_version|
+    platforms = {
+      "x86-mingw32" => "i686-w64-mingw32",
+      "x64-mingw32" => "x86_64-w64-mingw32"
+    }
+    platforms.each do |platform, prefix|
+      task "copy:bcrypt_ext:#{platform}:#{ruby_version}" do |t|
+        %w[lib tmp/#{platform}/stage/lib].each do |dir|
+          so_file = "#{dir}/#{ruby_version[/^\d+\.\d+/]}/bcrypt_ext.so"
+          if File.exists?(so_file)
+            sh "#{prefix}-strip -S #{so_file}"
+          end
+        end
+      end
+    end
+  end
 end
 
 desc "Run a set of benchmarks on the compiled extension."

data/appveyor.yml

@@ -0,0 +1,50 @@
+###############################################################################
+#
+# This AppVeyor config is *NOT* for running the tests on Windows.
+#
+# This is to ensure that the latest version of the bcrypt gem can be installed
+# on Windows across all of the currently supported versions of Ruby.
+#
+###############################################################################
+
+version: "{branch}-{build}"
+build: off
+clone_depth: 1
+
+init:
+  # Install Ruby 1.8.7
+  - if %RUBY_VERSION%==187 (
+      appveyor DownloadFile https://dl.bintray.com/oneclick/rubyinstaller/rubyinstaller-1.8.7-p374.exe -FileName C:\ruby_187.exe &
+      C:\ruby_187.exe /verysilent /dir=C:\Ruby%RUBY_VERSION%
+    )
+
+environment:
+  matrix:
+    - RUBY_VERSION: "187"
+    - RUBY_VERSION: "193"
+    - RUBY_VERSION: "200"
+    - RUBY_VERSION: "200-x64"
+    - RUBY_VERSION: "21"
+    - RUBY_VERSION: "21-x64"
+    - RUBY_VERSION: "22"
+    - RUBY_VERSION: "22-x64"
+    - RUBY_VERSION: "23"
+    - RUBY_VERSION: "23-x64"
+    - RUBY_VERSION: "24"
+    - RUBY_VERSION: "24-x64"
+    - RUBY_VERSION: "25"
+    - RUBY_VERSION: "25-x64"
+
+install:
+  - set PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
+  - if %RUBY_VERSION%==187 (
+      gem update --system 2.0.17
+    )
+
+before_test:
+  - ruby -v
+  - gem -v
+
+test_script:
+  - gem install bcrypt --prerelease --no-ri --no-rdoc
+  - ruby -e "require 'rubygems'; require 'bcrypt'"

data/bcrypt.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'bcrypt'
-  s.version = '3.1.7'
+  s.version = '3.1.12'
 
   s.summary = "OpenBSD's bcrypt() password hashing algorithm."
   s.description = <<-EOF
@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.require_path = 'lib'
 
   s.add_development_dependency 'rake-compiler', '~> 0.9.2'
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '>= 3'
   s.add_development_dependency 'rdoc', '~> 3.12'
 
   s.has_rdoc = true

data/ext/mri/bcrypt_ext.c

@@ -45,7 +45,7 @@ static VALUE bc_crypt(VALUE self, VALUE key, VALUE setting) {
 
     if(!value) return Qnil;
 
-    out = rb_str_new(data, size - 1);
+    out = rb_str_new2(value);
 
     xfree(data);
 

data/ext/mri/extconf.rb

@@ -11,7 +11,6 @@ if RUBY_PLATFORM == "java"
   exit 0
 else
   require "mkmf"
-  have_header('ruby/util.h')
   dir_config("bcrypt_ext")
   create_makefile("bcrypt_ext")
 end

data/lib/bcrypt/password.rb

@@ -80,7 +80,7 @@ module BCrypt
     # Splits +h+ into version, cost, salt, and hash and returns them in that order.
     def split_hash(h)
       _, v, c, mash = h.split('$')
-      return v, c.to_i, h[0, 29].to_str, mash[-31, 31].to_str
+      return v.to_str, c.to_i, h[0, 29].to_str, mash[-31, 31].to_str
     end
   end
 

data/spec/bcrypt/engine_spec.rb

@@ -4,35 +4,35 @@ describe "The BCrypt engine" do
   specify "should calculate the optimal cost factor to fit in a specific time" do
     first = BCrypt::Engine.calibrate(100)
     second = BCrypt::Engine.calibrate(400)
-    second.should > first
+    expect(second).to be > first
   end
 end
 
 describe "Generating BCrypt salts" do
 
   specify "should produce strings" do
-    BCrypt::Engine.generate_salt.should be_an_instance_of(String)
+    expect(BCrypt::Engine.generate_salt).to be_an_instance_of(String)
   end
 
   specify "should produce random data" do
-    BCrypt::Engine.generate_salt.should_not equal(BCrypt::Engine.generate_salt)
+    expect(BCrypt::Engine.generate_salt).to_not equal(BCrypt::Engine.generate_salt)
   end
 
   specify "should raise a InvalidCostError if the cost parameter isn't numeric" do
-    lambda { BCrypt::Engine.generate_salt('woo') }.should raise_error(BCrypt::Errors::InvalidCost)
+    expect { BCrypt::Engine.generate_salt('woo') }.to raise_error(BCrypt::Errors::InvalidCost)
   end
 
   specify "should raise a InvalidCostError if the cost parameter isn't greater than 0" do
-    lambda { BCrypt::Engine.generate_salt(-1) }.should raise_error(BCrypt::Errors::InvalidCost)
+    expect { BCrypt::Engine.generate_salt(-1) }.to raise_error(BCrypt::Errors::InvalidCost)
   end
 end
 
 describe "Autodetecting of salt cost" do
 
   specify "should work" do
-    BCrypt::Engine.autodetect_cost("$2a$08$hRx2IVeHNsTSYYtUWn61Ou").should eq 8
-    BCrypt::Engine.autodetect_cost("$2a$05$XKd1bMnLgUnc87qvbAaCUu").should eq 5
-    BCrypt::Engine.autodetect_cost("$2a$13$Lni.CZ6z5A7344POTFBBV.").should eq 13
+    expect(BCrypt::Engine.autodetect_cost("$2a$08$hRx2IVeHNsTSYYtUWn61Ou")).to eq 8
+    expect(BCrypt::Engine.autodetect_cost("$2a$05$XKd1bMnLgUnc87qvbAaCUu")).to eq 5
+    expect(BCrypt::Engine.autodetect_cost("$2a$13$Lni.CZ6z5A7344POTFBBV.")).to eq 13
   end
 
 end
@@ -49,21 +49,21 @@ describe "Generating BCrypt hashes" do
   end
 
   specify "should produce a string" do
-    BCrypt::Engine.hash_secret(@password, @salt).should be_an_instance_of(String)
+    expect(BCrypt::Engine.hash_secret(@password, @salt)).to be_an_instance_of(String)
   end
 
   specify "should raise an InvalidSalt error if the salt is invalid" do
-    lambda { BCrypt::Engine.hash_secret(@password, 'nino') }.should raise_error(BCrypt::Errors::InvalidSalt)
+    expect { BCrypt::Engine.hash_secret(@password, 'nino') }.to raise_error(BCrypt::Errors::InvalidSalt)
   end
 
   specify "should raise an InvalidSecret error if the secret is invalid" do
-    lambda { BCrypt::Engine.hash_secret(MyInvalidSecret.new, @salt) }.should raise_error(BCrypt::Errors::InvalidSecret)
-    lambda { BCrypt::Engine.hash_secret(nil, @salt) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
-    lambda { BCrypt::Engine.hash_secret(false, @salt) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
+    expect { BCrypt::Engine.hash_secret(MyInvalidSecret.new, @salt) }.to raise_error(BCrypt::Errors::InvalidSecret)
+    expect { BCrypt::Engine.hash_secret(nil, @salt) }.not_to raise_error
+    expect { BCrypt::Engine.hash_secret(false, @salt) }.not_to raise_error
   end
 
   specify "should call #to_s on the secret and use the return value as the actual secret data" do
-    BCrypt::Engine.hash_secret(false, @salt).should == BCrypt::Engine.hash_secret("false", @salt)
+    expect(BCrypt::Engine.hash_secret(false, @salt)).to eq BCrypt::Engine.hash_secret("false", @salt)
   end
 
   specify "should be interoperable with other implementations" do
@@ -76,7 +76,7 @@ describe "Generating BCrypt hashes" do
       ["0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", "$2a$05$abcdefghijklmnopqrstuu", "$2a$05$abcdefghijklmnopqrstuu5s2v8.iXieOjg/.AySBTTZIIVFJeBui"]
     ]
     for secret, salt, test_vector in test_vectors
-      BCrypt::Engine.hash_secret(secret, salt).should eql(test_vector)
+      expect(BCrypt::Engine.hash_secret(secret, salt)).to eql(test_vector)
     end
   end
 end

data/spec/bcrypt/error_spec.rb

@@ -4,13 +4,13 @@ describe "Errors" do
 
   shared_examples "descends from StandardError" do
     it "can be rescued as a StandardError" do
-      described_class.should < StandardError
+      expect(described_class).to be < StandardError
     end
   end
 
   shared_examples "descends from BCrypt::Error" do
     it "can be rescued as a BCrypt::Error" do
-      described_class.should < BCrypt::Error
+      expect(described_class).to be < BCrypt::Error
     end
   end
 

data/spec/bcrypt/password_spec.rb

@@ -8,23 +8,23 @@ describe "Creating a hashed password" do
   end
 
   specify "should return a BCrypt::Password" do
-    @password.should be_an_instance_of(BCrypt::Password)
+    expect(@password).to be_an_instance_of(BCrypt::Password)
   end
 
   specify "should return a valid bcrypt password" do
-    lambda { BCrypt::Password.new(@password) }.should_not raise_error
+    expect { BCrypt::Password.new(@password) }.not_to raise_error
   end
 
   specify "should behave normally if the secret is not a string" do
-    lambda { BCrypt::Password.create(nil) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
-    lambda { BCrypt::Password.create({:woo => "yeah"}) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
-    lambda { BCrypt::Password.create(false) }.should_not raise_error(BCrypt::Errors::InvalidSecret)
+    expect { BCrypt::Password.create(nil) }.not_to raise_error
+    expect { BCrypt::Password.create({:woo => "yeah"}) }.not_to raise_error
+    expect { BCrypt::Password.create(false) }.not_to raise_error
   end
 
   specify "should tolerate empty string secrets" do
-    lambda { BCrypt::Password.create( "\n".chop  ) }.should_not raise_error
-    lambda { BCrypt::Password.create( ""         ) }.should_not raise_error
-    lambda { BCrypt::Password.create( String.new ) }.should_not raise_error
+    expect { BCrypt::Password.create( "\n".chop  ) }.not_to raise_error
+    expect { BCrypt::Password.create( ""         ) }.not_to raise_error
+    expect { BCrypt::Password.create( String.new ) }.not_to raise_error
   end
 end
 
@@ -35,26 +35,26 @@ describe "Reading a hashed password" do
   end
 
   specify "the cost is too damn high" do
-    lambda {
+    expect {
       BCrypt::Password.create("hello", :cost => 32)
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   specify "the cost should be set to the default if nil" do
-    BCrypt::Password.create("hello", :cost => nil).cost.should equal(BCrypt::Engine::DEFAULT_COST)
+    expect(BCrypt::Password.create("hello", :cost => nil).cost).to equal(BCrypt::Engine::DEFAULT_COST)
   end
 
   specify "the cost should be set to the default if empty hash" do
-    BCrypt::Password.create("hello", {}).cost.should equal(BCrypt::Engine::DEFAULT_COST)
+    expect(BCrypt::Password.create("hello", {}).cost).to equal(BCrypt::Engine::DEFAULT_COST)
   end
 
   specify "the cost should be set to the passed value if provided" do
-    BCrypt::Password.create("hello", :cost => 5).cost.should equal(5)
+    expect(BCrypt::Password.create("hello", :cost => 5).cost).to equal(5)
   end
 
   specify "the cost should be set to the global value if set" do
     BCrypt::Engine.cost = 5
-    BCrypt::Password.create("hello").cost.should equal(5)
+    expect(BCrypt::Password.create("hello").cost).to equal(5)
     # unset the global value to not affect other tests
     BCrypt::Engine.cost = nil
   end
@@ -65,7 +65,7 @@ describe "Reading a hashed password" do
     old_default_cost = BCrypt::Engine::DEFAULT_COST
 
     BCrypt::Engine::DEFAULT_COST = 5
-    BCrypt::Password.create("hello").cost.should equal(5)
+    expect(BCrypt::Password.create("hello").cost).to equal(5)
 
     # reset default to not affect other tests
     BCrypt::Engine::DEFAULT_COST = old_default_cost
@@ -74,17 +74,18 @@ describe "Reading a hashed password" do
 
   specify "should read the version, cost, salt, and hash" do
     password = BCrypt::Password.new(@hash)
-    password.version.should eql("2a")
-    password.cost.should equal(5)
-    password.salt.should eql("$2a$05$CCCCCCCCCCCCCCCCCCCCC.")
-    password.salt.class.should eq String
-    password.checksum.should eq("E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW")
-    password.checksum.class.should eq String
-    password.to_s.should eql(@hash)
+    expect(password.version).to eql("2a")
+    expect(password.version.class).to eq String
+    expect(password.cost).to equal(5)
+    expect(password.salt).to eql("$2a$05$CCCCCCCCCCCCCCCCCCCCC.")
+    expect(password.salt.class).to eq String
+    expect(password.checksum).to eq("E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW")
+    expect(password.checksum.class).to eq String
+    expect(password.to_s).to eql(@hash)
   end
 
   specify "should raise an InvalidHashError when given an invalid hash" do
-    lambda { BCrypt::Password.new('weedle') }.should raise_error(BCrypt::Errors::InvalidHash)
+    expect { BCrypt::Password.new('weedle') }.to raise_error(BCrypt::Errors::InvalidHash)
   end
 end
 
@@ -96,28 +97,28 @@ describe "Comparing a hashed password with a secret" do
   end
 
   specify "should compare successfully to the original secret" do
-    (@password == @secret).should be(true)
+    expect((@password == @secret)).to be(true)
   end
 
   specify "should compare unsuccessfully to anything besides original secret" do
-    (@password == "@secret").should be(false)
+    expect((@password == "@secret")).to be(false)
   end
 end
 
 describe "Validating a generated salt" do
   specify "should not accept an invalid salt" do
-    BCrypt::Engine.valid_salt?("invalid").should eq(false)
+    expect(BCrypt::Engine.valid_salt?("invalid")).to eq(false)
   end
   specify "should accept a valid salt" do
-    BCrypt::Engine.valid_salt?(BCrypt::Engine.generate_salt).should eq(true)
+    expect(BCrypt::Engine.valid_salt?(BCrypt::Engine.generate_salt)).to eq(true)
   end
 end
 
 describe "Validating a password hash" do
   specify "should not accept an invalid password" do
-    BCrypt::Password.valid_hash?("i_am_so_not_valid").should be_false
+    expect(BCrypt::Password.valid_hash?("i_am_so_not_valid")).to be_falsey
   end
   specify "should accept a valid password" do
-    BCrypt::Password.valid_hash?(BCrypt::Password.create "i_am_so_valid").should be_true
+    expect(BCrypt::Password.valid_hash?(BCrypt::Password.create "i_am_so_valid")).to be_truthy
   end
 end

metadata

@@ -1,62 +1,73 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: bcrypt
-version: !ruby/object:Gem::Version 
-  version: 3.1.7
+version: !ruby/object:Gem::Version
+  version: 3.1.12
 platform: ruby
-authors: 
+authors:
 - Coda Hale
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-02-25 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2018-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake-compiler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.9.2
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - &id004 
-      - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rdoc
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        version: "3.12"
+      - !ruby/object:Gem::Version
+        version: '3.12'
   type: :development
-  version_requirements: *id003
-description: "    bcrypt() is a sophisticated and secure hash algorithm designed by The OpenBSD project\n    for hashing passwords. The bcrypt Ruby gem provides a simple wrapper for safely handling\n    passwords.\n"
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: ! "    bcrypt() is a sophisticated and secure hash algorithm designed
+  by The OpenBSD project\n    for hashing passwords. The bcrypt Ruby gem provides
+  a simple wrapper for safely handling\n    passwords.\n"
 email: coda.hale@gmail.com
 executables: []
-
-extensions: 
+extensions:
 - ext/mri/extconf.rb
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.md
 - COPYING
 - CHANGELOG
+- lib/bcrypt/password.rb
 - lib/bcrypt/engine.rb
 - lib/bcrypt/error.rb
-- lib/bcrypt/password.rb
 - lib/bcrypt.rb
-files: 
+files:
 - .gitignore
 - .rspec
 - .travis.yml
@@ -66,6 +77,7 @@ files:
 - Gemfile.lock
 - README.md
 - Rakefile
+- appveyor.yml
 - bcrypt.gemspec
 - ext/jruby/bcrypt_jruby/BCrypt.java
 - ext/mri/bcrypt_ext.c
@@ -86,32 +98,33 @@ files:
 - spec/bcrypt/password_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/codahale/bcrypt-ruby
-licenses: 
+licenses:
 - MIT
 metadata: {}
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --title
 - bcrypt-ruby
 - --line-numbers
 - --inline-source
 - --main
 - README.md
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id004
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id004
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: OpenBSD's bcrypt() password hashing algorithm.
 test_files: []
-