rbnacl 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da04c0339f10665de0880687721eb137edb0db2d
-  data.tar.gz: 4f149d92ee6701f70fa6f8715e6132357b6064fc
+  metadata.gz: ff876d588d1e3d16c902b3316141585d4172eab5
+  data.tar.gz: 7a22f5b8ea0fd18cdbc0a52d06880e81a53a742b
 SHA512:
-  metadata.gz: 7150574a248de534fa8f141eb891cc3db27a92988e319d55848d21f8323aa0f133416ffc5d4761c62b9d7dcaac7ef0ab70b7df2f45b42d540c857fc852b390a1
-  data.tar.gz: 08f8dfd718c3c75a436a826cc564beacb5533878f7b77d12ea0a057afc1750d421265b0c1172704e98953bece3c893926275aa991f6f86ba7d2d6ca2f85689b1
+  metadata.gz: e67a5a0fdc8293c993ddcf79cf1c21e92c68a31b393b37b8684b93cda182072441321fbb2eebc3612bb4061859c0d6d750d28417534200f5276beb9d221f6c24
+  data.tar.gz: 80220efc75c5d404172c70e589a5446d0e6b7d560ad85f530c57747f46ce63e3e72d2bcb3daed67d9d31c43dc5f9dd972cd102e2d20c014f79466ab29e85fecc

data/.travis.yml

@@ -3,7 +3,7 @@ script: "LD_LIBRARY_PATH=lib bundle exec rake ci"
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.1
+  - 2.1.2
   - ruby-head
   - jruby
   - jruby-head

data/CHANGES.md

@@ -1,3 +1,9 @@
+3.1.1 (2014-06-14)
+------------------
+* Fix undefined variable warning
+* RSpec 3 fixups
+* RuboCop
+
 3.1.0 (2014-05-22)
 ------------------
 * The scrypt password hashing function: RbNaCl::PasswordHash.scrypt

data/lib/rbnacl.rb

@@ -88,4 +88,4 @@ end
 Thread.exclusive { RbNaCl::Init.sodium_init }
 
 # Perform self test on load
-require "rbnacl/self_test" unless $RBNACL_SELF_TEST == false
+require "rbnacl/self_test" unless defined?($RBNACL_SELF_TEST) && $RBNACL_SELF_TEST == false

data/lib/rbnacl/version.rb

@@ -1,5 +1,5 @@
 # encoding: binary
 module RbNaCl
   # The library's version
-  VERSION = "3.1.0"
+  VERSION = "3.1.1"
 end

data/spec/rbnacl/boxes/curve25519xsalsa20poly1305/private_key_spec.rb

@@ -11,11 +11,11 @@ describe RbNaCl::PrivateKey do
     let(:secret_key) { RbNaCl::PrivateKey.generate }
 
     it "returns a secret key" do
-      secret_key.should be_a RbNaCl::PrivateKey
+      expect(secret_key).to be_a RbNaCl::PrivateKey
     end
 
     it "has the public key also set" do
-      secret_key.public_key.should be_a RbNaCl::PublicKey
+      expect(secret_key.public_key).to be_a RbNaCl::PublicKey
     end
   end
 
@@ -35,23 +35,23 @@ describe RbNaCl::PrivateKey do
 
   context "public_key" do
     it "returns a public key" do
-      subject.public_key.should be_a RbNaCl::PublicKey
+      expect(subject.public_key).to be_a RbNaCl::PublicKey
     end
 
     it "returns the correct public key" do
-      subject.public_key.to_s.should eql bobpk
+      expect(subject.public_key.to_s).to eql bobpk
     end
   end
 
   context "#to_bytes" do
     it "returns the bytes of the key" do
-      subject.to_s.should eq bobsk
+      expect(subject.to_s).to eq bobsk
     end
   end
 
   context "#to_s" do
     it "returns the raw bytes of the key" do
-      subject.to_bytes.should eq bobsk
+      expect(subject.to_bytes).to eq bobsk
     end
   end
 

data/spec/rbnacl/boxes/curve25519xsalsa20poly1305/public_key_spec.rb

@@ -22,13 +22,13 @@ describe RbNaCl::PublicKey do
 
   context "#to_bytes" do
     it "returns the bytes of the key" do
-      subject.to_bytes.should eq alicepk
+      expect(subject.to_bytes).to eq alicepk
     end
   end
 
   context "#to_s" do
     it "returns the bytes of the key" do
-      subject.to_s.should eq alicepk
+      expect(subject.to_s).to eq alicepk
     end
   end
 

data/spec/rbnacl/boxes/curve25519xsalsa20poly1305_spec.rb

@@ -9,11 +9,11 @@ describe RbNaCl::Box do
 
   context "new" do
     it "accepts strings" do
-      expect { RbNaCl::Box.new(alicepk, bobsk) }.to_not raise_error(Exception)
+      expect { RbNaCl::Box.new(alicepk, bobsk) }.to_not raise_error
     end
 
     it "accepts KeyPairs" do
-      expect { RbNaCl::Box.new(alice_key, bob_key) }.to_not raise_error(Exception)
+      expect { RbNaCl::Box.new(alice_key, bob_key) }.to_not raise_error
     end
 
     it "raises TypeError on a nil public key" do

data/spec/rbnacl/group_element_spec.rb

@@ -12,15 +12,15 @@ describe RbNaCl::GroupElement do
   subject { described_class.new(bob_public) }
 
   it "multiplies integers with the base point" do
-    described_class.base.mult(alice_private).to_s.should eq alice_public
+    expect(described_class.base.mult(alice_private).to_s).to eq alice_public
   end
 
   it "multiplies integers with arbitrary points" do
-    described_class.new(bob_public).mult(alice_private).to_s.should eq alice_mult_bob
+    expect(described_class.new(bob_public).mult(alice_private).to_s).to eq alice_mult_bob
   end
 
   it "serializes to bytes" do
-    subject.to_bytes.should eq bob_public
+    expect(subject.to_bytes).to eq bob_public
   end
 
   include_examples "serializable"

data/spec/rbnacl/hash_spec.rb

@@ -8,15 +8,15 @@ describe RbNaCl::Hash do
     let(:empty_string_hash)     { vector :sha256_empty }
 
     it "calculates the correct hash for a reference string" do
-      RbNaCl::Hash.sha256(reference_string).should eq reference_string_hash
+      expect(RbNaCl::Hash.sha256(reference_string)).to eq reference_string_hash
     end
 
     it "calculates the correct hash for an empty string" do
-      RbNaCl::Hash.sha256("").should eq empty_string_hash
+      expect(RbNaCl::Hash.sha256("")).to eq empty_string_hash
     end
 
     it "doesn't raise on a null byte" do
-      expect { RbNaCl::Hash.sha256("\0") }.to_not raise_error(/ArgumentError: string contains null byte/)
+      expect { RbNaCl::Hash.sha256("\0") }.to_not raise_error
     end
   end
 
@@ -26,15 +26,15 @@ describe RbNaCl::Hash do
     let(:empty_string_hash)     { vector :sha512_empty }
 
     it "calculates the correct hash for a reference string" do
-      RbNaCl::Hash.sha512(reference_string).should eq reference_string_hash
+      expect(RbNaCl::Hash.sha512(reference_string)).to eq reference_string_hash
     end
 
     it "calculates the correct hash for an empty string" do
-      RbNaCl::Hash.sha512("").should eq empty_string_hash
+      expect(RbNaCl::Hash.sha512("")).to eq empty_string_hash
     end
 
     it "doesn't raise on a null byte" do
-      expect { RbNaCl::Hash.sha512("\0") }.to_not raise_error(/ArgumentError: string contains null byte/)
+      expect { RbNaCl::Hash.sha512("\0") }.to_not raise_error
     end
   end
 end

data/spec/rbnacl/random_spec.rb

@@ -1,9 +1,9 @@
 # encoding: binary
 describe RbNaCl::Random do
   it "produces random bytes" do
-    RbNaCl::Random.random_bytes(16).bytesize.should == 16
+    expect(RbNaCl::Random.random_bytes(16).bytesize).to eq(16)
   end
   it "produces different random bytes" do
-    RbNaCl::Random.random_bytes(16).should_not == RbNaCl::Random.random_bytes(16)
+    expect(RbNaCl::Random.random_bytes(16)).not_to eq(RbNaCl::Random.random_bytes(16))
   end
 end

data/spec/rbnacl/secret_box_spec.rb

@@ -6,7 +6,7 @@ describe RbNaCl::SecretBox do
 
   context "new" do
     it "accepts strings" do
-      expect { RbNaCl::SecretBox.new(key) }.to_not raise_error(Exception)
+      expect { RbNaCl::SecretBox.new(key) }.to_not raise_error
     end
 
     it "raises on a nil key" do

data/spec/rbnacl/signatures/ed25519/signing_key_spec.rb

@@ -9,15 +9,15 @@ describe RbNaCl::SigningKey do
   subject { described_class.new(signing_key) }
 
   it "generates keys" do
-    described_class.generate.should be_a described_class
+    expect(described_class.generate).to be_a described_class
   end
 
   it "signs messages as bytes" do
-    subject.sign(message).should eq signature
+    expect(subject.sign(message)).to eq signature
   end
 
   it "serializes to bytes" do
-    subject.to_bytes.should eq signing_key
+    expect(subject.to_bytes).to eq signing_key
   end
 
   include_examples "key equality" do

data/spec/rbnacl/signatures/ed25519/verify_key_spec.rb

@@ -10,7 +10,7 @@ describe RbNaCl::VerifyKey do
   subject { RbNaCl::SigningKey.new(signing_key).verify_key }
 
   it "verifies correct signatures" do
-    subject.verify(signature, message).should be_true
+    expect(subject.verify(signature, message)).to eq true
   end
 
   it "raises when asked to verify a bad signature" do
@@ -22,11 +22,11 @@ describe RbNaCl::VerifyKey do
   end
 
   it "serializes to bytes" do
-    subject.to_bytes.should eq verify_key
+    expect(subject.to_bytes).to eq verify_key
   end
 
   it "initializes from bytes" do
-    described_class.new(verify_key).to_s.should eq verify_key
+    expect(described_class.new(verify_key).to_s).to eq verify_key
   end
 
   include_examples "key equality" do

data/spec/rbnacl/simple_box_spec.rb

@@ -15,7 +15,7 @@ describe RbNaCl::SimpleBox do
     end
 
     it "can be instantiated from a secret key" do
-      described_class.from_secret_key(secret_key).should be_a described_class
+      expect(described_class.from_secret_key(secret_key)).to be_a described_class
     end
 
     it "raises TypeError when given a nil secret key" do
@@ -23,7 +23,7 @@ describe RbNaCl::SimpleBox do
     end
 
     it "can be instantiated from a key-pair" do
-      described_class.from_keypair(alicepk, bobsk).should be_a described_class
+      expect(described_class.from_keypair(alicepk, bobsk)).to be_a described_class
     end
 
     it "raises TypeError when given nil secret keys in the pair" do
@@ -42,16 +42,16 @@ describe RbNaCl::SimpleBox do
     describe "bob" do
       it "decrypts a message from alice" do
         alices_ciphertext = alice.encrypt(message)
-        bob.decrypt(alices_ciphertext).should eql message
+        expect(bob.decrypt(alices_ciphertext)).to eql message
       end
 
       it "decrypts own message" do
         bobs_ciphertext = bob.encrypt(message)
-        bob.decrypt(bobs_ciphertext).should eql message
+        expect(bob.decrypt(bobs_ciphertext)).to eql message
       end
 
       it "decrypts a message with a 'random' nonce" do
-        bob.decrypt(nonce+ciphertext).should eql message
+        expect(bob.decrypt(nonce+ciphertext)).to eql message
       end
     end
   end

data/spec/rbnacl/util_spec.rb

@@ -8,12 +8,12 @@ describe RbNaCl::Util do
     let (:long_msg) { RbNaCl::Util.zeros(33) }
 
     it "confirms identical messages are identical" do
-      RbNaCl::Util.verify32!(msg, identical_msg).should be true
+      expect(RbNaCl::Util.verify32!(msg, identical_msg)).to be true
     end
 
     it "confirms non-identical messages are non-identical" do
-      RbNaCl::Util.verify32!(msg, other_msg).should be false
-      RbNaCl::Util.verify32!(other_msg, msg).should be false
+      expect(RbNaCl::Util.verify32!(msg, other_msg)).to be false
+      expect(RbNaCl::Util.verify32!(other_msg, msg)).to be false
     end
 
     it "raises descriptively on a short message in position 1" do
@@ -38,16 +38,16 @@ describe RbNaCl::Util do
     let (:long_msg) { RbNaCl::Util.zeros(33) }
 
     it "confirms identical messages are identical" do
-      RbNaCl::Util.verify32(msg, identical_msg).should be true
+      expect(RbNaCl::Util.verify32(msg, identical_msg)).to be true
     end
 
     it "confirms non-identical messages are non-identical" do
-      RbNaCl::Util.verify32(msg, other_msg).should be false
-      RbNaCl::Util.verify32(other_msg, msg).should be false
-      RbNaCl::Util.verify32(short_msg, msg).should be false
-      RbNaCl::Util.verify32(msg, short_msg).should be false
-      RbNaCl::Util.verify32(long_msg, msg).should be false
-      RbNaCl::Util.verify32(msg, long_msg).should be false
+      expect(RbNaCl::Util.verify32(msg, other_msg)).to be false
+      expect(RbNaCl::Util.verify32(other_msg, msg)).to be false
+      expect(RbNaCl::Util.verify32(short_msg, msg)).to be false
+      expect(RbNaCl::Util.verify32(msg, short_msg)).to be false
+      expect(RbNaCl::Util.verify32(long_msg, msg)).to be false
+      expect(RbNaCl::Util.verify32(msg, long_msg)).to be false
     end
 
   end
@@ -60,12 +60,12 @@ describe RbNaCl::Util do
     let (:long_msg) { RbNaCl::Util.zeros(17) }
 
     it "confirms identical messages are identical" do
-      RbNaCl::Util.verify16!(msg, identical_msg).should be true
+      expect(RbNaCl::Util.verify16!(msg, identical_msg)).to be true
     end
 
     it "confirms non-identical messages are non-identical" do
-      RbNaCl::Util.verify16!(msg, other_msg).should be false
-      RbNaCl::Util.verify16!(other_msg, msg).should be false
+      expect(RbNaCl::Util.verify16!(msg, other_msg)).to be false
+      expect(RbNaCl::Util.verify16!(other_msg, msg)).to be false
     end
 
     it "raises descriptively on a short message in position 1" do
@@ -90,16 +90,16 @@ describe RbNaCl::Util do
     let (:long_msg) { RbNaCl::Util.zeros(17) }
 
     it "confirms identical messages are identical" do
-      RbNaCl::Util.verify16(msg, identical_msg).should be true
+      expect(RbNaCl::Util.verify16(msg, identical_msg)).to be true
     end
 
     it "confirms non-identical messages are non-identical" do
-      RbNaCl::Util.verify16(msg, other_msg).should be false
-      RbNaCl::Util.verify16(other_msg, msg).should be false
-      RbNaCl::Util.verify16(short_msg, msg).should be false
-      RbNaCl::Util.verify16(msg, short_msg).should be false
-      RbNaCl::Util.verify16(long_msg, msg).should be false
-      RbNaCl::Util.verify16(msg, long_msg).should be false
+      expect(RbNaCl::Util.verify16(msg, other_msg)).to be false
+      expect(RbNaCl::Util.verify16(other_msg, msg)).to be false
+      expect(RbNaCl::Util.verify16(short_msg, msg)).to be false
+      expect(RbNaCl::Util.verify16(msg, short_msg)).to be false
+      expect(RbNaCl::Util.verify16(long_msg, msg)).to be false
+      expect(RbNaCl::Util.verify16(msg, long_msg)).to be false
     end
   end
 
@@ -133,11 +133,11 @@ describe RbNaCl::Util do
     let (:hex)   { "deadbeef" }
 
     it "encodes to hex with bin2hex" do
-      RbNaCl::Util.bin2hex(bytes).should eq hex
+      expect(RbNaCl::Util.bin2hex(bytes)).to eq hex
     end
 
     it "decodes from hex with hex2bin" do
-      RbNaCl::Util.hex2bin(hex).should eq bytes
+      expect(RbNaCl::Util.hex2bin(hex)).to eq bytes
     end
   end
 end

data/spec/shared/authenticator.rb

@@ -5,7 +5,7 @@ shared_examples "authenticator" do
 
   context ".new" do
     it "accepts a key" do
-      expect { described_class.new(key) }.to_not raise_error(ArgumentError)
+      expect { described_class.new(key) }.to_not raise_error
     end
 
     it "requires a key" do
@@ -27,7 +27,7 @@ shared_examples "authenticator" do
 
   context ".auth" do
     it "produces an authenticator" do
-      described_class.auth(key, message).should eq tag
+      expect(described_class.auth(key, message)).to eq tag
     end
 
     it "raises TypeError on a nil key" do
@@ -41,7 +41,7 @@ shared_examples "authenticator" do
 
   context ".verify" do
     it "verify an authenticator" do
-      described_class.verify(key, tag, message).should eq true
+      expect(described_class.verify(key, tag, message)).to eq true
     end
 
     it "raises TypeError on a nil key" do
@@ -70,13 +70,13 @@ shared_examples "authenticator" do
 
     context "#auth" do
       it "produces an authenticator" do
-        authenticator.auth(message).should eq tag
+        expect(authenticator.auth(message)).to eq tag
       end
     end
 
     context "#verify" do
       it "verifies an authenticator" do
-        authenticator.verify(tag, message).should be true
+        expect(authenticator.verify(tag, message)).to be true
       end
 
       it "fails to validate an invalid authenticator" do

data/spec/shared/box.rb

@@ -12,7 +12,7 @@ shared_examples "box" do
   context "box" do
 
     it "encrypts a message" do
-      box.box(nonce, message).should eq ciphertext
+      expect(box.box(nonce, message)).to eq ciphertext
     end
 
     it "raises on a short nonce" do
@@ -27,7 +27,7 @@ shared_examples "box" do
   context "open" do
 
     it "decrypts a message" do
-      box.open(nonce, ciphertext).should eq message
+      expect(box.open(nonce, ciphertext)).to eq message
     end
 
     it "raises on a truncated message to decrypt" do

data/spec/shared/key_equality.rb

@@ -2,25 +2,25 @@
 shared_examples "key equality" do
   context "equality" do
     it "equal keys are equal" do
-      (described_class.new(key_bytes) == key).should be true
+      expect(described_class.new(key_bytes) == key).to be true
     end
     it "equal keys are equal to the string" do
-      (key == key_bytes).should be true
+      expect(key == key_bytes).to be true
     end
     it "keys are not equal to zero" do
-      (key == RbNaCl::Util.zeros(32)).should be false
+      expect(key == RbNaCl::Util.zeros(32)).to be false
     end
     it "keys are not equal to another key" do
-      (key == other_key).should be false
+      expect(key == other_key).to be false
     end
   end
 
   context "lexicographic sorting" do
     it "can be compared lexicographically to a key smaller than it" do
-      (key > RbNaCl::Util.zeros(32)).should be true
+      expect(key > RbNaCl::Util.zeros(32)).to be true
     end
     it "can be compared lexicographically to a key larger than it" do
-      (described_class.new(RbNaCl::Util.zeros(32)) < key).should be true
+      expect(described_class.new(RbNaCl::Util.zeros(32)) < key).to be true
     end
   end
 end

data/tasks/rubocop.rake

@@ -1,3 +1,3 @@
 require 'rubocop/rake_task'
 
-Rubocop::RakeTask.new
+RuboCop::RakeTask.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbnacl
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Tony Arcieri
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain:
 - bascule.cert
-date: 2014-05-23 00:00:00.000000000 Z
+date: 2014-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi