fix(tool): update rand library

remove yarn lock file

use sliceRandom instead of deprecated choose method

remove yarn lock

clean and move u64 to f64 rng

fix test roundtrip

Author: sendilkumarn

Cargo.toml

@@ -25,7 +25,7 @@ itertools = "*"
 json = "*"
 log = "*"
 lzw = "*"
-rand = "^0.4"
+rand = "^0.6"
 test-logger = "*"
 vec_map = "*"
 webidl = "*"

crates/binjs_generic/Cargo.toml

@@ -18,7 +18,7 @@ binjs_meta = { path = "../binjs_meta", version = "*" }
 binjs_shared = { path = "../binjs_shared", version = "*" }
 json = "^0.11"
 log = "*"
-rand = "^0.4"
+rand = "^0.6"
 
 [dev-dependencies]
 clap = "^2.30"

crates/binjs_generic/src/pick.rs

@@ -1,10 +1,12 @@
 use util::pick;
 
 use binjs_meta::spec::*;
+use std::iter;
 
 use json;
 use json::JsonValue as JSON;
 use rand;
+use rand::distributions::Alphanumeric;
 
 pub trait Pick {
     fn random<T: rand::Rng>(&self, syntax: &Spec, rng: &mut T, depth_limit: isize) -> JSON;
@@ -69,11 +71,11 @@ impl Pick for TypeSpec {
             {
                 const MAX_STRING_LEN : usize = 10;
                 let len = rng.gen_range(0, MAX_STRING_LEN);
-                let string : String = rng.gen_ascii_chars().take(len).collect();
+                let string : String = iter::repeat(()).map(|()| rng.sample(Alphanumeric)).take(len).collect();
                 json::from(string)
             }
             TypeSpec::Number => {
-                json::from(rng.next_f64())
+                json::from(rng.gen::<f64>())
             }
             TypeSpec::Void =>
                 JSON::Null,

crates/binjs_io/Cargo.toml

@@ -13,7 +13,7 @@ flate2 = "^1.0"
 itertools = "*"
 lzw = "*"
 log = "*"
-rand = "^0.4"
+rand = "^0.6"
 range-encoding = "0.1.9"
 serde = "^1.0"
 serde_derive = "^1.0"

crates/binjs_io/src/bytes/compress.rs

@@ -3,8 +3,11 @@
 use bytes::serialize::*;
 use bytes::varnum::*;
 
-use rand;
-use rand::{ Rand, Rng };
+use rand::Rng;
+use rand::distributions::Distribution;
+use rand::distributions::Standard;
+use rand::thread_rng;
+use rand::seq::SliceRandom;
 
 use std;
 use std::collections::HashSet;
@@ -32,11 +35,12 @@ pub enum Compression {
     Lzw,
 }
 
-impl Rand for Compression {
-    fn rand<R: Rng>(rng: &mut R) -> Self {
+impl Distribution<Compression> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Compression {
         use self::Compression::*;
-        rng.choose(&[Identity, Gzip, /* Deflate is apprently broken https://github.com/alexcrichton/flate2-rs/issues/151 , */ Brotli /*, Lzw doesn't work yet */])
-            .unwrap() // The array is not empty.
+        let choices = [Identity, Gzip, /* Deflate is apprently broken https://github.com/alexcrichton/flate2-rs/issues/151 , */ Brotli /*, Lzw doesn't work yet */];
+        choices.choose(rng)
+            .unwrap()
             .clone()
     }
 }
@@ -79,7 +83,7 @@ impl Compression {
             Some("br") => Compression::Brotli,
             Some("gzip") => Compression::Gzip,
             Some("deflate") => Compression::Deflate,
-            Some("random") => Compression::rand(&mut rand::weak_rng()),
+            Some("random") => thread_rng().gen(),
             Some(_) => {
                 return None;
             }

crates/binjs_io/src/lib.rs

@@ -26,7 +26,9 @@ use std::fmt::{ Debug, Formatter };
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use rand::{ Rand, Rng };
+use rand::Rng;
+use rand::distributions::{ Distribution, Standard };
+use rand::seq::SliceRandom;
 
 pub use bytes::compress::Compression;
 
@@ -163,9 +165,9 @@ impl CompressionTarget {
 
 /// Support picking a random compression target.
 /// Used for testing.
-impl Rand for CompressionTarget {
-    fn rand<R: Rng>(rng: &mut R) -> Self {
-        Self::new(Compression::rand(rng))
+impl Distribution<CompressionTarget> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> CompressionTarget {
+        CompressionTarget::new(rng.gen())
     }
 }
 impl std::io::Write for CompressionTarget {
@@ -213,27 +215,27 @@ pub enum Format {
 
 /// Support picking a random format.
 /// Used for testing.
-impl Rand for Format {
-    fn rand<'a, R: Rng>(rng: &'a mut R) -> Self {
+impl Distribution<Format> for Standard {
+    fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> Format {
         let generators = [
-            Rc::new(|_| Self::simple()) as Rc<Fn(&'a mut R) -> Format>,
+            Rc::new(|_| Format::simple()) as Rc<Fn(&'a mut R) -> Format>,
             Rc::new(|rng| {
                 use multipart::{ Statistics, Targets };
                 let stats = Rc::new(RefCell::new(Statistics::default()
                     .with_source_bytes(0)));
 
                 Format::Multipart {
                     targets: Targets {
-                        strings_table: CompressionTarget::rand(rng),
-                        grammar_table: CompressionTarget::rand(rng),
-                        tree: CompressionTarget::rand(rng),
+                        strings_table: rng.gen(),
+                        grammar_table: rng.gen(),
+                        tree: rng.gen(),
                     },
                     stats
                 }
             }),
             Rc::new(|_| Format::XML),
         ];
-        let pick : Rc<Fn(&'a mut R) -> Format> = rng.choose(&generators)
+        let pick : Rc<Fn(&'a mut R) -> Format> = generators.choose(rng)
             .map(Rc::clone)
             .unwrap(); // Never empty
         pick(rng)
@@ -254,9 +256,9 @@ impl Format {
             Format::Multipart { stats, .. } =>
                 Format::Multipart {
                     targets: multipart::Targets {
-                        strings_table: CompressionTarget::rand(rng),
-                        grammar_table: CompressionTarget::rand(rng),
-                        tree: CompressionTarget::rand(rng),
+                        strings_table: rng.gen(),
+                        grammar_table: rng.gen(),
+                        tree: rng.gen(),
                     },
                     stats
                 }

src/util/mod.rs

@@ -1,6 +1,7 @@
 use binjs_generic::syntax::ASTError;
 
 use rand;
+use rand::distributions::Alphanumeric;
 use json::JsonValue as JSON;
 use json::object::Object as Object;
 
@@ -11,17 +12,17 @@ use std::path::*;
 pub fn get_temporary_file(extension: &str) -> std::result::Result<(PathBuf, File), std::io::Error> {
     use rand::Rng;
     let directory = std::env::temp_dir();
-    let mut rng = rand::os::OsRng::new()
+    let mut rng = rand::rngs::OsRng::new()
         .unwrap();
-    let mut ascii = rng.gen_ascii_chars();
+    let ascii = rng.sample(Alphanumeric);
     let mut buf = Vec::with_capacity(8);
     let mut error = None;
     const ATTEMPTS : usize = 1024;
     for _ in 0..ATTEMPTS { // Limit number of attempts
         // FIXME: There must be a nicer way to do this.
         buf.clear();
         for _ in 0..8 {
-            buf.push(ascii.next().unwrap());
+            buf.push(ascii);
         }
         let name : String = buf.iter().collect();
         let path = directory.as_path()

tests/test_roundtrip.rs

@@ -18,8 +18,6 @@ use binjs::specialized::es6::ast::{ IOPath, Script, Visitor, Walker, WalkPath };
 use std::io::Cursor;
 use std::thread;
 
-use rand::Rng;
-
 /// This test takes 1h+ on Travis, which is too long, so we need to
 /// reduce it. So each individual file + options combination has
 /// a `CHANCES_TO_SKIP` probability of being skipped.
@@ -36,8 +34,8 @@ fn progress() {
 ///
 /// Skipping is generally needed to avoid timeouts, because we
 /// are testing lots of files.
-fn should_skip(rng: &mut Rng) -> bool {
-    let float = rng.next_f64();
+fn should_skip<T: rand::Rng>(rng: &mut T) -> bool {
+    let float = rng.gen::<f64>();
     float < CHANCES_TO_SKIP
 }