fix warnings, add doc

Author: gutschilla

README.md

@@ -13,18 +13,23 @@ unimportant validation codes and stuff like that.
 Notes
 =====
 
-Strings will only contain a-z, A-Z and 0-9 characters.
+Strings will only contain a-z, A-Z and 0-9 characters and will always start with
+a character.
 
 Numbers may be shorter than length. (Due to possible start with 0)
 
 The whole thing relies on Erlang's random:uniform/1 - I don't know if this is a
 secure PRNG or not, so better do not use this module for security stuff.
 
-Todo
-====
+Motivation
+============
 
-Add documentation, generate String of numbers.
+1. Detects OTP version and uses `:random.seed` or `:rand.seed` with either
+   `:erlang.now` or `:erlang.monotonic_time` as both the rand module and using
+   erland.now got deprecated in OTP 17 and 18.
+   
+2. I use it all the time.
 
-LICENSE
+License
 =======
 MIT

lib/random.ex

@@ -1,56 +1,119 @@
 defmodule Misc.Random do
 
-    def seed_random do
-        use_monotonic = :erlang.module_info
-            |> Keyword.get( :exports )
-            |> Keyword.get( :monotonic_time )
-        time_bif = case use_monotonic do
-          1   -> &:erlang.monotonic_time/0
-          nil -> &:erlang.now/0
-        end
-        :random.seed( time_bif.() )
+  def seed_random do
+    try do
+      get_otp_version() |> seed()
+    catch
+      _, _ -> seed()
     end
+  end
 
-    def string( length ) do
-        get_string( length )
-    end
+  def get_otp_version do
+    :otp_release
+    |> :erlang.system_info()
+    |> to_string()
+    |> Integer.parse()
+    |> elem(0)
+  end
 
-    def string() do
-        get_string( 8 )
-    end
+  # this work on OTP 17 w/o warnings
+  def seed do
+    :erlang.now() |> :random.seed()
+  end
 
-    def get_string( length ) do
-        seed_random
-        alphabet
-            =  "abcdefghijklmnopqrstuvwxyz"
-            <> "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-            <> "0123456789"
-        alphabet_length =
-        alphabet |> String.length
-
-        1..length
-          |> Enum.map_join(
-            fn(_) ->
-              alphabet |> String.at( :random.uniform( alphabet_length ) - 1 )
-            end
-          )
-    end
+  def seed(otp_version) when otp_version <= 17 do
+    seed()
+  end
 
-    def number() do
-        get_number(8)
-    end
+  # use of erlang.now is deprecated in OTP 18
+  def seed(otp_version) when otp_version == 18 do
+    :erlang.monotonic_time() |> :random.seed()
+  end
 
-    def number( length ) do
-        get_number( length )
-    end
+  # random is deperecated for rand in OTP 19
+  def seed(otp_version) when otp_version >= 19 do
+    now = {
+      :erlang.phash2([node()]),
+      :erlang.monotonic_time(),
+      :erlang.unique_integer()
+    }
+    :rand.seed(:exsplus, now)
+  end
+
+  @doc """
+  Generates a random string that will always start with a character.
+  """
+  def string(length \\ 8) do
+    seed_random()
+    get_string(length)
+  end
+
+  defp get_string(1) do
+    default_alphabet(:alpha) |> get_random_char
+  end
+
+  defp get_string(length) when length > 1 do
+    first = get_string(1)
+    rest  = Enum.map_join(2..length, fn _ -> default_alphabet() |> get_random_char() end)
+    first <> rest
+  end
+
+  def get_random_char(alphabet) do
+    alphabet_length = alphabet |> String.length
+    get_random_char(alphabet, alphabet_length)
+  end
 
-    def get_number( length ) do
-        seed_random
+  def get_random_char(alphabet, alphabet_length) do
+    alphabet |> String.at(uniform(alphabet_length) - 1)
+  end
 
-        { number, "" } = 
-          Integer.parse 1..length 
-          |> Enum.map_join( fn(_) ->  :random.uniform(10) - 1 end )
-        number
+  @doc """
+  Generates a random number as string that will not start with leading zeroes.
+  """
+  def number(length \\ 8) do
+   seed_random()
+   length
+   |> get_number()
+   |> Integer.parse()
+   |> elem(0)
+  end
+
+  defp get_number(1) do
+    default_alphabet(:numeric_wo_zeroes) |> get_random_char()
+  end
+
+  defp get_number(length) when is_integer(length) do
+    first = get_number(1)
+    rest  = Enum.map_join(2..length, fn _ -> default_alphabet(:numeric) |> get_random_char end)
+    first <> rest
+  end
+
+  def default_alphabet do
+    default_alphabet(:alpha) <> default_alphabet(:numeric)
+  end
+
+  def default_alphabet(:alpha) do
+    "abcdefghijklmnopqrstuvwxyz" <> "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  end
+
+  def default_alphabet(:numeric) do
+    default_alphabet(:numeric_wo_zeroes) <> "0"
+  end
+
+  def default_alphabet(:numeric_wo_zeroes) do
+    "123456789"
+  end
+
+  def uniform(x) do
+    try do
+      get_otp_version() |> get_uniform(x)
+    catch
+      _, _ -> get_uniform(x)
     end
+  end
+
+  def get_uniform(x), do: x |> :random.uniform
+  def get_uniform(otp_version, x) when otp_version <= 18,       do: x |> get_uniform(x)
+  def get_uniform(otp_version, x) when is_integer(otp_version), do: x |> :rand.uniform
 
 end

mix.exs

@@ -3,11 +3,11 @@ defmodule Misc.Random.Mixfile do
 
   def project do
     [app: :misc_random,
-     version: "0.2.6",
+     version: "0.2.8",
      elixir: "> 1.0.0",
-     description: description,
-     package: package,
-     deps: deps]
+     description: description(),
+     package: package(),
+     deps: deps()]
   end
 
   # Configuration for the OTP application
@@ -32,11 +32,11 @@ defmodule Misc.Random.Mixfile do
 
   defp description do
     """
-    This is a very thin wrapper around erlang's random:uniform method. It allows
-    you to create random strings or numbers.
+    Creates random numbers and strings of arbitrary lengths. Uses preferred
+    Erlang random module based on used OTP version.
     """
   end
-  
+
   defp package do
     [# These are the default files included in the package
      files: ["lib", "mix.exs", "README*", "LICENSE*"],

test/random_test.exs

@@ -13,6 +13,28 @@ defmodule Misc.RandomTest do
         assert String.length( string ) == 8
     end
 
+    test "strings always start with a character" do
+      string_starts_with_character = fn length ->
+        length
+        |> Misc.Random.string
+        |> String.match?(~r/\A[a-z]/i)
+      end
+     1..100 |> Enum.all?(string_starts_with_character) |> assert
+    end
+
+    test "numbers have desired length (no leading zeroes)" do
+      numbers_have_desired_length = fn length ->
+        number    = length |> Misc.Random.number
+        length_ok = number |> to_string |> String.length |> Kernel.==(length)
+        start_ok  = number |> to_string |> String.match?(~r/\A[1-9]/)
+        if not length_ok do
+          IO.inspect([length, number])
+        end
+        start_ok and length_ok
+      end
+      1..100 |> Enum.all?(numbers_have_desired_length) |> assert
+    end
+
     test "generate number" do
         number = Misc.Random.number()
         assert is_integer number