super_random 1.2.200123 → 2.0.210126

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aeb192c166b91d82fb0a4b535d851a5479c5bae43bf4a37d607ae199b128d83d
-  data.tar.gz: 6fb7ad8629f9775183a65c040dc762d48e178a761c545008028e57c0002162dd
+  metadata.gz: 2480d12416526288677a0a9203d7e63ae666eb70b59fc792cc1a67bc2c35978a
+  data.tar.gz: 52d9c2e334770c1498f6afffc1bc967db38686a1d5098882f2b1290bbf5f1e60
 SHA512:
-  metadata.gz: c51049b6220c0c971146cd2ddc0463dcbd7037c7bc7695aca8a50653d8acd22cc2964d85f66d667ad311526f2e0a8748d0e4a2e501f9621aa64db0f524d78883
-  data.tar.gz: f583c0095ca47c209730afa445bca8304f041d55de8c0f26e599e9cac7770bbdc3f4001e2e9fc82fe8e24ea70a5c9063d01e12e616a6708bc88dcfd71c990f8d
+  metadata.gz: 3dcb0cb30658abd969e2930cc60bc9d0ff33bca7b4dc7ee0e418c43ba6f9815d52c7af4c21346320ff7941422e2ff8fbbb75a3e0453c9172edf3f05e5a0609ff
+  data.tar.gz: c0b24a58b9a236992b615a3bad666af0d5377575dabed3fd760cc3b2857904f9bec41ed3ee0f186c11820979c0bea50cf4f52de580ff6a576d3dc253a2644f43

data/README.md

@@ -1,6 +1,6 @@
 # SuperRandom
 
-* [VERSION 1.2.200123](https://github.com/carlosjhr64/super_random/releases)
+* [VERSION 2.0.210126](https://github.com/carlosjhr64/super_random/releases)
 * [github](https://github.com/carlosjhr64/super_random)
 * [rubygems](https://rubygems.org/gems/super_random)
 
@@ -8,45 +8,51 @@
 
 You can't get more random than random, but you can try really, really, really hard.
 
-SuperRandom combines five online real random services to create a more perfect random byte.
-
-## SYNOPSIS:
-
-    require 'super_random'
-    super_random = SuperRandom.new
-
-    super_random.bytes(32) #~> ^\[\d+(, \d+){31}\]$
-    # Example:
-    # [142, 36, 107, 199, 1, 222, 69, 238, 130, 159, 236, 201, 199,
-    #   33, 237, 166, 189, 166, 95, 246, 111, 103, 113, 126, 27, 31,
-    #  244, 215, 200, 60, 255, 184]
-
-    super_random.hexadecimal(32) #~> ^\h{64}$
-    # Example:
-    # "3e0dffe42c08b849dc3c1290e7aa87dff4ad3037b29694136786a4db1e3efab8"
-
-    super_random.random_number(100.0) #~> ^\d{1,2}\.\d+$
-    # Example:
-    # 16.882225652425537
-
-    super_random.random_number(100) #~> ^\d{1,2}$
-    # Example:
-    # 85
-
-    # The "services" attribute gives the number of online services used.
-    # It's possible for a service to fail.
-    # Ultimately, SuperRandom uses SecureRandom as a failsafe.
-    super_random.services #=> 5
+SuperRandom combines three online real random services to create a more perfect random byte.
 
 ## INSTALL:
 
     $ gem install super_random
 
+## SYNOPSIS:
+
+```ruby
+require 'super_random'
+super_random = SuperRandom.new
+
+super_random.bytes(32) #~> ^\[\d+(, \d+){31}\]$
+# Example:
+# [142, 36, 107, 199, 1, 222, 69, 238, 130, 159, 236, 201, 199,
+#   33, 237, 166, 189, 166, 95, 246, 111, 103, 113, 126, 27, 31,
+#  244, 215, 200, 60, 255, 184]
+
+sleep 1 # rate limit to be nice
+super_random.hexadecimal(32) #~> ^\h{64}$
+# Example:
+# "3e0dffe42c08b849dc3c1290e7aa87dff4ad3037b29694136786a4db1e3efab8"
+
+sleep 1
+super_random.random_number(100.0) #~> ^\d{1,2}\.\d+$
+# Example:
+# 16.882225652425537
+
+sleep 1
+super_random.random_number(100) #~> ^\d{1,2}$
+# Example:
+# 85
+
+# The "services" attribute gives the number of online services used.
+# It's possible for a service to fail.
+# Ultimately, SuperRandom uses SecureRandom as a failsafe.
+super_random.services   #=> 3
+super_random.randomness #=> 3.0
+```
+
 ## LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2020 carlosjhr64
+Copyright (c) 2021 carlosjhr64
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/super_random.rb

@@ -1,15 +1,15 @@
-class SuperRandom
-  VERSION = '1.2.200123'
-end
-
 # Standard Libraries
 require 'timeout'
 require 'securerandom'
 require 'net/http'
 require 'json'
 
-# This Gem
-require 'super_random/super_random.rb'
+class SuperRandom
+  VERSION = '2.0.210126'
+  # This Gem
+  require 'super_random/services'
+  require 'super_random/generator'
+end
 
 # Requires:
 #`ruby`

data/lib/super_random/generator.rb

@@ -0,0 +1,99 @@
+class SuperRandom
+  DEFAULT_BYTES = 32
+
+  attr_accessor :first_timeout, :second_timeout, :nevermind
+  attr_reader :randomness, :services
+
+  def initialize
+    @first_timeout = 3
+    @second_timeout = 6
+    @nevermind = true
+    @randomness = 0.0
+    @services = 0
+  end
+
+  def bytes(n=DEFAULT_BYTES)
+    @randomness = 0.0
+    @services = 0
+
+    m = SuperRandom.services
+    a = Array.new m.length
+    t = Array.new m.length
+    m.each_with_index do |k,i|
+      t[i] = Thread.new{ a[i] = SuperRandom.send(k, n) }
+    end
+
+    begin
+      Timeout.timeout(@first_timeout) do
+        # Initially, would like to get them all.
+        t.each{_1.join}
+      end
+    rescue Timeout::Error
+      begin
+        Timeout.timeout(@second_timeout) do
+          # But at this point,
+          # would like to get at least one.
+          while a.all?{_1.nil?} and t.any?{_1.alive?}
+            Thread.pass
+          end
+        end
+      rescue Timeout::Error
+        # If we don't care that we got nothing, go on.
+        raise $! unless @nevermind
+      end
+    end
+
+    r = Array.new n
+    n.times{|i| r[i] = SecureRandom.random_number(256)}
+
+    a.each do |b|
+      next if b.nil?
+      l = b.length
+      @randomness += l.to_f/n.to_f
+      @services += 1
+      n.times{|i|r[i]=(r[i]+b[i%l])%256}
+    end
+
+    return r
+  end
+
+  def hexadecimal(n=DEFAULT_BYTES)
+    bytes(n).map{|i|i.to_s(16).rjust(2,'0')}.join
+  end
+
+  def random_number(scale=1.0, minbytes=6, maxbytes=[minbytes,DEFAULT_BYTES].max)
+    case scale
+    when Float
+      div = minbytes.times.inject(''){|s,i| s+'FF'}.to_i(16)
+      den = hexadecimal(minbytes).to_i(16)
+      return  scale * den.to_f / div.to_f
+    when Integer
+      n = n0 = Math.log(scale, 256).ceil
+      e = e0 = 256**n
+      r = r0 = e0 % scale
+      while r > 0
+        n0 += 1
+        e0 *= 256
+        r0 = e0 % scale
+        if r0 <= r
+          # break if repeating pattern with big enough integer
+          break if r0 == r and n0 > minbytes
+          r,n,e = r0,n0,e0
+        end
+        break if n0 >= maxbytes
+      end
+      max = (e/scale)*scale
+      loop do
+        number = hexadecimal(n).to_i(16)
+        return number % scale if number < max
+        # On a relatively small chance that we're above max...
+        if @nevermind
+          warn "using SecureRandom.random_number(#{scale})"
+          return SecureRandom.random_number(scale)
+        end
+      end
+    end
+    raise "rand(scale Integer|Float)"
+  end
+  alias rand random_number
+end

data/lib/super_random/services.rb

@@ -0,0 +1,45 @@
+class SuperRandom
+  def self.services
+    [:quantum, :atmospheric, :hotbits]
+  end
+
+  # https://qrng.anu.edu.au/
+  # https://qrng.anu.edu.au/contact/api-documentation/
+  def self.quantum(n)
+    s = Net::HTTP.get(URI(
+      "https://qrng.anu.edu.au/API/jsonI.php?length=#{n}&type=uint8"))
+    a = JSON.parse(s)['data']
+    raise unless a.is_a?(Array) and a.length==n
+    raise unless a.all?{|i| i.is_a?(Integer) and i.between?(0,255)}
+    return a
+  rescue StandardError
+    warn "quantum (qrng.anu.edu.au) failed."
+    return nil
+  end
+
+  # https://www.random.org/
+  # https://www.random.org/integers/
+  def self.atmospheric(n)
+    s = Net::HTTP.get(URI(
+      "https://www.random.org/integers/?num=#{n}&min=0&max=255&col=1&base=10&format=plain&rnd=new"))
+    a = s.strip.split(/\s+/).map{|j|j.to_i}
+    raise unless a.length==n
+    raise unless a.all?{|i| i.between?(0,255)}
+    return a
+  rescue StandardError
+    warn "atmospheric (www.random.org) failed."
+    return nil
+  end
+
+  # https://www.fourmilab.ch/hotbits/
+  def self.hotbits(n, k='Pseudorandom')
+    s = Net::HTTP.get(URI(
+      "https://www.fourmilab.ch/cgi-bin/Hotbits.api?nbytes=#{n}&fmt=bin&apikey=#{k}"))
+    a = s.bytes
+    raise unless a.length==n
+    return a
+  rescue StandardError
+    warn "hotbits (www.fourmilab.ch) failed."
+    return nil
+  end
+end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: super_random
 version: !ruby/object:Gem::Version
-  version: 1.2.200123
+  version: 2.0.210126
 platform: ruby
 authors:
 - carlosjhr64
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-23 00:00:00.000000000 Z
+date: 2021-01-26 00:00:00.000000000 Z
 dependencies: []
 description: |
   You can't get more random than random, but you can try really, really, really hard.
 
-  SuperRandom combines five online real random services to create a more perfect random byte.
+  SuperRandom combines three online real random services to create a more perfect random byte.
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
@@ -21,12 +21,13 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/super_random.rb
-- lib/super_random/super_random.rb
+- lib/super_random/generator.rb
+- lib/super_random/services.rb
 homepage: https://github.com/carlosjhr64/super_random
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -41,9 +42,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux]'
-rubygems_version: 3.1.2
-signing_key: 
+- 'ruby: ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-linux]'
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: You can't get more random than random, but you can try really, really, really
   hard.

data/lib/super_random/super_random.rb

@@ -1,165 +0,0 @@
-class SuperRandom
-  DEFAULT_BYTES = 32
-
-  # http://qrng.anu.edu.au/index.php
-  # https://qrng.anu.edu.au/API/api-demo.php
-  def self.quantum(n)
-    s = Net::HTTP.get(URI(
-      "https://qrng.anu.edu.au/API/jsonI.php?length=#{n}&type=uint8"))
-    a = JSON.parse(s)['data']
-    raise unless a.is_a?(Array) and a.length==n
-    raise unless a.all?{|i| i.is_a?(Integer) and i.between?(0,255)}
-    return a
-  rescue StandardError
-    warn "quantum (qrng.anu.edu.au) failed."
-    return nil
-  end
-
-  # https://www.random.org/
-  # https://www.random.org/integers/
-  def self.atmospheric(n)
-    s = Net::HTTP.get(URI(
-      "https://www.random.org/integers/?num=#{n}&min=0&max=255&col=1&base=10&format=plain&rnd=new"))
-    a = s.strip.split(/\s+/).map{|j|j.to_i}
-    raise unless a.length==n
-    raise unless a.all?{|i| i.between?(0,255)}
-    return a
-  rescue StandardError
-    warn "atmospheric (www.random.org) failed."
-    return nil
-  end
-
-  # http://random.hd.org/
-  # http://random.hd.org/getBits.jsp
-  def self.entropy_pool(n)
-    s = Net::HTTP.get(URI(
-      "http://random.hd.org/getBits.jsp?numBytes=#{n}&type=bin"))
-    a = s.bytes
-    # As of the time of this writting, not guaranteed to get more than 8 bytes.
-    raise unless (n>8)? a.length.between?(8,n) : a.length==n
-    return a
-  rescue StandardError
-    warn "entropy_pool (random.hd.org) failed."
-    return nil
-  end
-
-  # https://www.fourmilab.ch/hotbits/
-  def self.hotbits(n, k='Pseudorandom')
-    s = Net::HTTP.get(URI(
-      "https://www.fourmilab.ch/cgi-bin/Hotbits.api?nbytes=#{n}&fmt=bin&apikey=#{k}"))
-    a = s.bytes
-    raise unless a.length==n
-    return a
-  rescue StandardError
-    warn "hotbits (www.fourmilab.ch) failed."
-    return nil
-  end
-
-  # http://www.randomnumbers.info
-  def self.quantis(n)
-    s = Net::HTTP.get(URI(
-      "http://www.randomnumbers.info/cgibin/wqrng.cgi?amount=#{n}&limit=255"))
-    a = s.scan( /\s\d\d?\d?\b/ ).map{|i| i.to_i}
-    raise unless a.length == n and a.all?{|i| i.between?(0,255)}
-    return a
-  rescue
-    warn "quantis (www.randomnumbers.info) failed."
-    return nil
-  end
-
-  attr_accessor :first_timeout, :second_timeout, :nevermind
-  attr_reader :randomness, :services
-
-  def initialize
-    @first_timeout = 3
-    @second_timeout = 6
-    @nevermind = true
-    @randomness = 0.0
-    @services = 0
-  end
-
-  def bytes(n=DEFAULT_BYTES)
-    @randomness = 0.0
-    @services = 0
-
-    a1 = a2 = a3 = a4 = a5 = nil
-
-    t1 = Thread.new{ a1 = SuperRandom.quantum(n)}
-    t2 = Thread.new{ a2 = SuperRandom.atmospheric(n)}
-    t3 = Thread.new{ a3 = SuperRandom.entropy_pool(n)}
-    t4 = Thread.new{ a4 = SuperRandom.hotbits(n)}
-    t5 = Thread.new{ a5 = SuperRandom.quantis(n)}
-
-    begin
-      Timeout.timeout(@first_timeout) do
-        # Initially, would like to get them all.
-        t1.join and t2.join and t3.join and t4.join and t5.join
-      end
-    rescue Timeout::Error
-      begin
-        Timeout.timeout(@second_timeout) do
-          # But at this point,
-          # would like to get at least one.
-          while [a1,a2,a3,a4,a5].all?{|a|a.nil?} and [t1,t2,t3,t4,t5].any?{|t|t.alive?}
-            Thread.pass
-          end
-        end
-      rescue Timeout::Error
-        # If we don't care that we got nothing, go on.
-        raise $! unless @nevermind
-      end
-    end
-
-    a = n.times.inject([]){|b,i|b.push(SecureRandom.random_number(256))}
-    [a1, a2, a3, a4, a5].each do |b|
-      if b
-        bl = b.length
-        @randomness += bl.to_f/n.to_f
-        @services += 1
-        n.times{|i|a[i]=(a[i]+b[i%bl])%256}
-      end
-    end
-
-    return a
-  end
-
-  def hexadecimal(n=DEFAULT_BYTES)
-    bytes(n).map{|i|i.to_s(16).rjust(2,'0')}.join
-  end
-
-  def random_number(scale=1.0, minbytes=6, maxbytes=[minbytes,DEFAULT_BYTES].max)
-    case scale
-    when Float
-      div = minbytes.times.inject(''){|s,i| s+'FF'}.to_i(16)
-      den = hexadecimal(minbytes).to_i(16)
-      return  scale * den.to_f / div.to_f
-    when Integer
-      n = n0 = Math.log(scale, 256).ceil
-      e = e0 = 256**n
-      r = r0 = e0 % scale
-      while r > 0
-        n0 += 1
-        e0 *= 256
-        r0 = e0 % scale
-        if r0 <= r
-          # break if repeating pattern with big enough integer
-          break if r0 == r and n0 > minbytes
-          r,n,e = r0,n0,e0
-        end
-        break if n0 >= maxbytes
-      end
-      max = (e/scale)*scale
-      loop do
-        number = hexadecimal(n).to_i(16)
-        return number % scale if number < max
-        # On a relatively small chance that we're above max...
-        if @nevermind
-          warn "using SecureRandom.random_number(#{scale})"
-          return SecureRandom.random_number(scale)
-        end
-      end
-    end
-    raise "rand(scale Integer|Float)"
-  end
-  alias rand random_number
-end