bcrypt 3.1.7-x64-mingw32 → 3.1.8-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA512: 
-  metadata.gz: 973d1bd8509b0d42d35977d769bf2522b5e4ec01f45d05e48d842624554941a8cf1a23b56b8baf7a848620ad9cae95d2b702bd70bae10f79f83b8fceb290fd04
-  data.tar.gz: 241d54653cc5770d02a833b467644a9a40f0f94bc2e8ff4a0b728cda0404754d16beb158a2d3ae4966118e0b5fa626fac6130cc01dc851658536048491825127
+  metadata.gz: a358fa7b9694351c998b9ff6b55a121e8bec47bf8b94939a6c588d9ed62fa2dacf632abc8d19573103fd418d7fca284d1071199c60ace8802cf9918e33ce185e
+  data.tar.gz: 52a226e5ad26e9fb5b34a49fa9a5bcdc2a2338cd252e2f82dc3311aede4b2d87f23533a244d492e08d0489478fd829404cacd0b571191721b66812615226132b
 SHA1: 
-  metadata.gz: 96f13c22771da12ea1b60189599305a6e43feba1
-  data.tar.gz: 495beb691cef42e506a3849699af701c1e7c3f30
+  metadata.gz: b4ec10390181d48fc7e70f344ddbcdcd9114a98d
+  data.tar.gz: cc1680870b7380d6c0c82d61d0bae05a5eef7a1e

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

@@ -10,6 +10,5 @@ rvm:
   - jruby-19mode
   - jruby-head
   - rbx-2
-  - rbx
   - ree
 script: bundle exec rake

data/CHANGELOG

@@ -70,3 +70,6 @@
 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]

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bcrypt (3.1.7)
+    bcrypt (3.1.8)
 
 GEM
   remote: https://rubygems.org/
@@ -14,14 +14,18 @@ GEM
       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.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.2)
 
 PLATFORMS
   java
@@ -33,4 +37,4 @@ DEPENDENCIES
   bcrypt!
   rake-compiler (~> 0.9.2)
   rdoc (~> 3.12)
-  rspec
+  rspec (>= 3)

data/README.md

@@ -30,7 +30,7 @@ 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
+* RubyInstaller 1.8, 1.9, 2.0, and 2.1 builds on win32
 * Any 1.8, 1.9, 2.0, or 2.1 ruby on a BSD/OSX/Linux system with a compiler
 
 ## How to use `bcrypt()` in your Rails application

data/Rakefile

@@ -7,16 +7,19 @@ 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/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 +61,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/bcrypt.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'bcrypt'
-  s.version = '3.1.7'
+  s.version = '3.1.8'
 
   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/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.rb

@@ -9,12 +9,7 @@ else
   require "openssl"
 end
 
-begin
-  RUBY_VERSION =~ /(\d+.\d+)/
-  require "#{$1}/bcrypt_ext"
-rescue LoadError
-  require "bcrypt_ext"
-end
+require 'bcrypt_ext'
 
 require 'bcrypt/error'
 require 'bcrypt/engine'

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,17 @@ 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.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 +96,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bcrypt
 version: !ruby/object:Gem::Version 
-  version: 3.1.7
+  version: 3.1.8
 platform: x64-mingw32
 authors: 
 - Coda Hale
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-02-25 00:00:00 Z
+date: 2014-10-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake-compiler
@@ -19,19 +19,18 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version 
         version: 0.9.2
-  type: :development
   version_requirements: *id001
+  type: :development
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
-    - &id004 
-      - ">="
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
-  type: :development
+        version: "3"
   version_requirements: *id002
+  type: :development
 - !ruby/object:Gem::Dependency 
   name: rdoc
   prerelease: false
@@ -40,8 +39,8 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version 
         version: "3.12"
-  type: :development
   version_requirements: *id003
+  type: :development
 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: []
@@ -86,6 +85,7 @@ files:
 - spec/bcrypt/password_spec.rb
 - spec/spec_helper.rb
 - lib/2.0/bcrypt_ext.so
+- lib/2.1/bcrypt_ext.so
 homepage: https://github.com/codahale/bcrypt-ruby
 licenses: 
 - MIT
@@ -103,7 +103,10 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - *id004
+  - &id004 
+    - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - *id004