Update some code to make it more julian (#114)

* Update cipher.jl

Make the internals more julian.

* Update hash_common.jl

Update hash_common.jl to make it more julian.

* Update hash.jl

Make it more julian, dropping`AbstractString` in favor of `String`.

* Update hmac.jl

Make it more julian, dropping`AbstractString` in favor of `String`.

* Update cipher.jl

Fix indentation

Author: nandoconde

src/cipher.jl

@@ -21,7 +21,7 @@ end
 
 # For much the same reasons as in hash_common.jl, we define a separate, more "Julia friendly" type
 struct CipherType
-    name::AbstractString
+    name::String
     context_size::Cuint
     block_size::Cuint
     key_size::Cuint
@@ -49,7 +49,7 @@ function CipherType(nc::NettleCipher)
 end
 
 # The global dictionary of hash types we know how to construct
-const _cipher_types = Dict{AbstractString,CipherType}()
+const _cipher_types = Dict{String,CipherType}()
 
 # We're going to load in each NettleCipher struct individually, deriving
 # HashAlgorithm types off of the names we find, and storing the output
@@ -83,20 +83,20 @@ function gen_key32_iv16(pw::Vector{UInt8}, salt::Vector{UInt8})
 end
 
 function add_padding_PKCS5(data::Vector{UInt8}, block_size::Int)
-  padlen = block_size - (sizeof(data) % block_size)
-  return [data; map(i -> UInt8(padlen), 1:padlen)]
+    padlen = block_size - (sizeof(data) % block_size)
+    return [data; map(i -> UInt8(padlen), 1:padlen)]
 end
 
 function trim_padding_PKCS5(data::Vector{UInt8})
-  padlen = data[sizeof(data)]
-  if all(data[end-padlen+1:end-1] .== data[end])
-    return data[1:sizeof(data)-padlen]
-  else
-    throw(ArgumentError("Invalid PKCS5 padding"))
-  end
+    padlen = data[end]
+    if all(data[end-padlen+1:end-1] .== data[end])
+        return data[1:end-padlen]
+    else
+        throw(ArgumentError("Invalid PKCS5 padding"))
+    end
 end
 
-function Encryptor(name::AbstractString, key)
+function Encryptor(name::String, key)
     cipher_types = get_cipher_types()
     name = uppercase(name)
     if !haskey(cipher_types, name)
@@ -114,7 +114,7 @@ function Encryptor(name::AbstractString, key)
     return Encryptor(cipher_type, state)
 end
 
-function Decryptor(name::AbstractString, key)
+function Decryptor(name::String, key)
     cipher_types = get_cipher_types()
     name = uppercase(name)
     if !haskey(cipher_types, name)
@@ -253,11 +253,11 @@ function encrypt(state::Encryptor, data)
 end
 
 # The one-shot functions that make this whole thing so easy
-decrypt(name::AbstractString, key, data) = decrypt(Decryptor(name, key), data)
-encrypt(name::AbstractString, key, data) = encrypt(Encryptor(name, key), data)
+decrypt(name::String, key, data) = decrypt(Decryptor(name, key), data)
+encrypt(name::String, key, data) = encrypt(Encryptor(name, key), data)
 
-decrypt(name::AbstractString, e::Symbol, iv::Vector{UInt8}, key, data) = decrypt(Decryptor(name, key), e, iv, data)
-encrypt(name::AbstractString, e::Symbol, iv::Vector{UInt8}, key, data) = encrypt(Encryptor(name, key), e, iv, data)
+decrypt(name::String, e::Symbol, iv::Vector{UInt8}, key, data) = decrypt(Decryptor(name, key), e, iv, data)
+encrypt(name::String, e::Symbol, iv::Vector{UInt8}, key, data) = encrypt(Encryptor(name, key), e, iv, data)
 
 # Custom show overrides make this package have a little more pizzaz!
 function show(io::IO, x::CipherType)

src/hash.jl

@@ -10,7 +10,7 @@ struct Hasher
 end
 
 # Constructor for Hasher
-function Hasher(name::AbstractString)
+function Hasher(name::String)
     hash_types = get_hash_types()
     name = uppercase(name)
     if !haskey(hash_types, name)
@@ -41,10 +41,10 @@ end
 hexdigest!(state::Hasher) = bytes2hex(digest!(state))
 
 # The one-shot functions that makes this whole thing so easy.
-digest(hash_name::AbstractString, data) = digest!(update!(Hasher(hash_name), data))
-digest(hash_name::AbstractString, io::IO) = digest(hash_name, readall(io))
-hexdigest(hash_name::AbstractString, data) = hexdigest!(update!(Hasher(hash_name), data))
-hexdigest(hash_name::AbstractString, io::IO) = hexdigest(hash_name, readall(io))
+digest(hash_name::String, data) = digest!(update!(Hasher(hash_name), data))
+digest(hash_name::String, io::IO) = digest(hash_name, readall(io))
+hexdigest(hash_name::String, data) = hexdigest!(update!(Hasher(hash_name), data))
+hexdigest(hash_name::String, io::IO) = hexdigest(hash_name, readall(io))
 
 # Custom show overrides make this package have a little more pizzaz!
 function show(io::IO, x::HashType)

src/hash_common.jl

@@ -37,7 +37,7 @@ function HashType(nh::NettleHash, nhptr::Ptr{Cvoid})
 end
 
 # The global dictionary of hash types we know how to construct
-const _hash_types = Dict{AbstractString,HashType}()
+const _hash_types = Dict{String,HashType}()
 
 # We're going to load in each NettleHash struct individually, deriving
 # HashAlgorithm types off of the names we find, and storing the output

src/hmac.jl

@@ -13,7 +13,7 @@ struct HMACState
 end
 
 # Constructor for HMACState
-function HMACState(name::AbstractString, key)
+function HMACState(name::String, key)
     hash_types = get_hash_types()
     name = uppercase(name)
     if !haskey(hash_types, name)
@@ -47,7 +47,7 @@ end
 hexdigest!(state::HMACState) = bytes2hex(digest!(state))
 
 # The one-shot functions that makes this whole thing so easy
-digest(hmac_name::AbstractString, key, data) = digest!(update!(HMACState(hmac_name, key), data))
-hexdigest(hmac_name::AbstractString, key, data) = hexdigest!(update!(HMACState(hmac_name, key), data))
+digest(hmac_name::String, key, data) = digest!(update!(HMACState(hmac_name, key), data))
+hexdigest(hmac_name::String, key, data) = hexdigest!(update!(HMACState(hmac_name, key), data))
 
 show(io::IO, x::HMACState) = write(io, "$(x.hash_type.name) HMAC state")