Minor cleanup

2 files changed, 50 insertions, 46 deletions

diff --git a/HLintIgnores b/HLintIgnores
new file mode 100644
index 0000000..473a245
--- /dev/null
+++ b/HLintIgnores
@@ -0,0 +1,9 @@
+{-# ANN module ("HLint: ignore Eta reduce"::String) #-}
+{-# ANN module ("HLint: ignore Use camelCase"::String) #-}
+{-# ANN module ("HLint: ignore Redundant bracket"::String) #-}
+{-# ANN module ("HLint: ignore Redundant $"::String) #-}
+{-# ANN module ("HLint: ignore Redundant do"::String) #-}
+{-# ANN module ("HLint: ignore Use String"::String) #-}
+{-# ANN module ("HLint: ignore Use ||"::String) #-}
+{-# ANN module ("HLint: ignore Use &&"::String) #-}
+{-# ANN module ("HLint: ignore Use ***"::String) #-}
diff --git a/KeyRing.hs b/KeyRing.hs
index 10baa98..869cbb3 100644
--- a/KeyRing.hs
+++ b/KeyRing.hs
@@ -280,7 +280,7 @@ instance ASN1Object PKCS8_RSAPublicKey where
                          : End Sequence
                          : xs
         where
-            pubkey = Start Sequence : IntVal n : IntVal e : End Sequence : []
+            pubkey = [ Start Sequence, IntVal n, IntVal e, End Sequence ]
             bs = encodeASN1' DER pubkey
 
     fromASN1 (Start Sequence:IntVal modulus:IntVal pubexp:End Sequence:xs) =
@@ -658,9 +658,9 @@ parseSpec grip spec = (topspec,subspec)
                     _ | null top && null grip -> KeyUidMatch sub
                     _ | null top -> KeyGrip grip
                     _ | toptyp=="fp" || (null toptyp && is40digitHex top)
-                                 -> {- trace "using top" $ -} KeyGrip top
+                                 -> KeyGrip top
                     _ | toptyp=="u" -> KeyUidMatch top
-                    _ | otherwise -> KeyUidMatch top
+                    _            -> KeyUidMatch top
      subspec = case subtyp of
                 "t" -> Just sub
                 "fp" | top=="" -> Nothing
@@ -721,12 +721,12 @@ seek_key (KeyGrip grip) sec = (pre, subs)
     pred p@(PublicKeyPacket {}) = matchpr grip p == grip
     pred _                      = False
 
-seek_key (KeyTag key tag) ps = if null bs
-                                then (ps,[])
-                                else if null qs
-                                 then let (as',bs') = seek_key (KeyTag key tag) (tail bs)
-                                      in (as ++ (head bs:as'), bs')
-                                 else (reverse (tail qs), head qs : reverse rs ++ bs)
+seek_key (KeyTag key tag) ps
+    | null bs = (ps, [])
+    | null qs =
+      let (as', bs') = seek_key (KeyTag key tag) (tail bs) in
+        (as ++ (head bs : as'), bs')
+    | otherwise = (reverse (tail qs), head qs : reverse rs ++ bs)
   where
     (as,bs) = break (\p -> isSignaturePacket p
                         && has_tag tag p
@@ -738,15 +738,13 @@ seek_key (KeyTag key tag) ps = if null bs
     has_tag tag p = tag `elem` mapMaybe usage (hashed_subpackets p)
                     || tag `elem` map usageString (mapMaybe keyflags (hashed_subpackets p))
 
-seek_key (KeyUidMatch pat) ps = if null bs
-                                then (ps,[])
-                                else if null qs
-                                 then let (as',bs') = seek_key (KeyUidMatch pat) (tail bs)
-                                      in (as ++ (head bs:as'), bs')
-                                 else (reverse (tail qs), head qs : reverse rs ++ bs)
+seek_key (KeyUidMatch pat) ps
+    | null bs = (ps, [])
+    | null qs = let (as', bs') = seek_key (KeyUidMatch pat) (tail bs) in
+                    (as ++ (head bs : as'), bs')
+    | otherwise = (reverse (tail qs), head qs : reverse rs ++ bs)
   where
-    (as,bs) = break (isInfixOf pat . uidStr)
-                    ps
+    (as,bs) = break (isInfixOf pat . uidStr) ps
     (rs,qs) = break isKey (reverse as)
 
     uidStr (UserIDPacket s) = s
@@ -844,7 +842,7 @@ mergeHostFiles krd db secring pubring = do
     
     -- 2. replace gpg annotations with those in U
     -- forM use_db
-    db' <- Traversable.mapM (setHostnames (\a -> not $ elem a outgoing_names) u1) db
+    db' <- Traversable.mapM (setHostnames (`notElem` outgoing_names) u1) db
 
     return $ KikiSuccess ((db',(hostdbs0,hostdbs,u1,gpgnames,outgoing_names)),[])
 
@@ -882,7 +880,7 @@ writeHostsFiles krd secring pubring (hostdbs0,hostdbs,u1,gpgnames,outgoing_names
         let h = h1 `Hosts.plus` u
             d = Hosts.diff h0 h
             rs = map ((fname,) . HostsDiff) d
-        when (not $ null d) $ L.writeFile fname $ Hosts.encode h
+        unless (null d) $ L.writeFile fname $ Hosts.encode h
         return rs
     return $ concat rss
 
@@ -969,7 +967,7 @@ buildKeyDB doDecrypt secring pubring grip0 keyring = do
     return $ KikiSuccess ( (db, grip, mwk, hs), reportWallets ++ reportPEMs )
 
 torhash :: Packet -> String
-torhash key = maybe "" id $ derToBase32 <$> derRSA key
+torhash key = fromMaybe "" $ derToBase32 <$> derRSA key
 
 derToBase32 :: ByteString -> String
 derToBase32 = map toLower . Base32.encode . S.unpack . SHA1.hashlazy
@@ -1166,7 +1164,7 @@ coinKeysOwnedBy db wk = do
     (subkk,SubKey mp sigs) <- Map.toList subs
     let sub = packet mp
     guard $ isCryptoCoinKey sub
-    tag <- take 1 $ mapMaybe getCryptoCoinTag (map (packet . fst) sigs)
+    tag <- take 1 $ mapMaybe (getCryptoCoinTag . packet . fst) sigs
     return (tag,mp)
 
 walletImportFormat :: Word8 -> Packet -> String
@@ -1432,14 +1430,14 @@ makeMemoizingDecrypter operation secring pubring = do
             decryptIt [] = return BadPassphrase
             decryptIt (getpw:getpws) = do
                 pw <- getpw
-                let wkun = maybe wk id $ decryptSecretKey pw wk
+                let wkun = fromMaybe wk $ decryptSecretKey pw wk
                 case symmetric_algorithm wkun of
                     Unencrypted -> do
                         writeIORef unkeysRef (Map.insert kk wkun unkeys)
                         return $ KikiSuccess wkun
                     _ -> decryptIt getpws
 
-            getpws = mapMaybe (flip Map.lookup pws) fs
+            getpws = mapMaybe (`Map.lookup` pws) fs
 
         case symmetric_algorithm wk of
             Unencrypted -> return (KikiSuccess wk)
@@ -1521,7 +1519,7 @@ initializeMissingPEMFiles operation secring pubring grip decrypt db = do
         let (missing,notmissing) = partition (\(_,_,ns,_)->null (ns >>= snd)) $ do
                 (fname,(rtyp,ftyp)) <- nonexistents
                 guard $ isMutable rtyp
-                (topspec,subspec) <- fmap (parseSpec $ maybe "" id grip)
+                (topspec,subspec) <- fmap (parseSpec $ fromMaybe "" grip)
                                        $ getUsage ftyp
                 -- ms will contain duplicates if a top key has multiple matching
                 -- subkeys.  This is intentional.
@@ -1552,7 +1550,7 @@ initializeMissingPEMFiles operation secring pubring grip decrypt db = do
                        return (fname,subspec,ms,cmd)
            rs <- forM cmds $ \tup@(fname,subspec,ms,cmd) -> do
                e <- systemEnv [ ("file",fname)
-                              , ("usage",maybe "" id subspec) ]
+                              , ("usage",fromMaybe "" subspec) ]
                               cmd
                case e of
                  ExitFailure num -> return (tup,FailedExternal num)
@@ -1754,10 +1752,10 @@ secretToPublic pkt = pkt
 slurpWIPKeys :: Posix.EpochTime -> L.ByteString -> ( [(Word8,Packet)], [L.ByteString])
 slurpWIPKeys stamp "" = ([],[])
 slurpWIPKeys stamp cs =
-    let (b58,xs) = Char8.span (\x -> elem x base58chars) cs
+    let (b58,xs) = Char8.span (`elem` base58chars) cs
         mb        = decode_btc_key stamp (Char8.unpack b58)
     in if L.null b58
-        then let (ys,xs') = Char8.break (\x -> elem x base58chars) cs
+        then let (ys,xs') = Char8.break (`elem` base58chars) cs
                  (ks,js)  = slurpWIPKeys stamp xs'
              in (ks,ys:js)
         else let (ks,js) = slurpWIPKeys stamp xs
@@ -1810,14 +1808,11 @@ decode_btc_key timestamp str = do
             }
 
 rsaKeyFromPacket :: Packet -> Maybe RSAPublicKey
-rsaKeyFromPacket p@(PublicKeyPacket {}) = do
-    n <- lookup 'n' $ key p
-    e <- lookup 'e' $ key p
-    return $ RSAKey n e
-rsaKeyFromPacket p@(SecretKeyPacket {}) = do
+rsaKeyFromPacket p | isKey p = do
     n <- lookup 'n' $ key p
     e <- lookup 'e' $ key p
     return $ RSAKey n e
+
 rsaKeyFromPacket _ = Nothing
 
 
@@ -1830,7 +1825,7 @@ readPacketsFromWallet wk fname = do
                     modificationTime <$> getFileStatus fname
     input <- L.readFile fname
     let (ks,_) = slurpWIPKeys timestamp input
-    when (not (null ks)) $ do
+    unless (null ks) $ do
         -- decrypt wk
         -- create sigs
         -- return key/sig pairs
@@ -1862,7 +1857,7 @@ now = floor <$> Data.Time.Clock.POSIX.getPOSIXTime
 signature_time :: SignatureOver -> Word32
 signature_time ov = case if null cs then ds else cs of
                                 [] -> minBound
-                                xs -> last (sort xs)
+                                xs -> maximum xs
           where
             ps = signatures_over ov
             ss = filter isSignaturePacket ps
@@ -1898,7 +1893,7 @@ findTag tag wk subkey subsigs = (xs',minsig,ys')
                                 guard (isSignaturePacket sig)
                                 guard $ flip isSuffixOf
                                              (fingerprint wk)
-                                        . maybe "%bad%" id
+                                        . fromMaybe "%bad%" 
                                         . signature_issuer
                                         $ sig
                                 listToMaybe $
@@ -1932,13 +1927,13 @@ makeSig doDecrypt top fname subkey_p tag mbsig = do
     wkun <- doDecrypt top
     try wkun $ \wkun -> do
     let grip = fingerprint wk
-        addOrigin new_sig = do
+        addOrigin new_sig =
             flip (maybe $ return FailedToMakeSignature)
                  (new_sig >>= listToMaybe . signatures_over)
                  $ \new_sig -> do
             let mp' = mappedPacket fname new_sig
             return $ KikiSuccess (mp', Map.empty)
-        parsedkey = [packet $ subkey_p]
+        parsedkey = [packet subkey_p]
         hashed0 =
                     [ KeyFlagsPacket
                         { certify_keys = False
@@ -1997,7 +1992,7 @@ makeSig doDecrypt top fname subkey_p tag mbsig = do
                  map unwrap es where unwrap (SignatureExpirationTimePacket x) = x
         expires = liftA2 (+) stamp exp
     timestamp <- now
-    if fmap ( (< timestamp) . fromIntegral) expires == Just True then do
+    if fmap ( (< timestamp) . fromIntegral) expires == Just True then
         return $ KikiSuccess ((mp,trustmap), [ UnableToUpdateExpiredSignature ] )
     else do
         let times = (:) (SignatureExpirationTimePacket (fromIntegral timestamp))
@@ -2091,7 +2086,7 @@ merge db filename (Message ps) = merge_ db filename qs
                 _ | isKey p && is_subkey p       -> (top,p,ret p)
                 _ | isUserID p                   -> (top,p,ret p)
                 _ | isTrust p                    -> (top,sub,updateTrust top sub prev p)
-                _ | otherwise                    -> (top,sub,ret p)
+                _                                -> (top,sub,ret p)
 
         updateTrust top (PublicKeyPacket {}) (pre,t) p = (pre,Map.insert filename p t) -- public
         updateTrust (PublicKeyPacket {}) _   (pre,t) p = (pre,Map.insert filename p t) -- public
@@ -2226,7 +2221,7 @@ merge_ db filename qs = foldl mergeit db (zip [0..] qs)
 
 unsig :: FilePath -> Bool -> SigAndTrust -> [MappedPacket]
 unsig fname isPublic (sig,trustmap) =
-    [sig]++ map (asMapped (-1)) ( take 1 . Map.elems $ Map.filterWithKey f trustmap)
+    sig : map (asMapped (-1)) ( take 1 . Map.elems $ Map.filterWithKey f trustmap)
   where
     f n _ = n==fname -- && trace ("fname=n="++show n) True
     asMapped n p = let m = mappedPacket fname p
@@ -2290,7 +2285,7 @@ getHostnames (KeyData topmp _ uids subs) = (addr,(onames,othernames))
             _ -> mzero
 
     addr = fingerdress topk
-    -- name = maybe "" id $ listToMaybe onames -- TODO: more than one tor key?
+    -- name = fromMaybe "" $ listToMaybe onames -- TODO: more than one tor key?
     topk = packet topmp
     torkeys = do
         SubKey k sigs <- Map.elems subs
@@ -2311,7 +2306,7 @@ getHostnames (KeyData topmp _ uids subs) = (addr,(onames,othernames))
                 guard . not . null $ signatures_over v'
                 return torsig
         guard (not $ null sigs')
-        return $ subk
+        return subk
     has_tag tag p = isSignaturePacket p
                     && or [ tag `elem` mapMaybe usage (hashed_subpackets p)
                           , tag `elem` map usageString (mapMaybe keyflags (hashed_subpackets p)) ]
@@ -2386,14 +2381,14 @@ setHostnames pred hosts kd@(KeyData topmp topsigs uids subs) =
             psig = packet sig
             p' = if isSignaturePacket psig then psig { unhashed_subpackets = ps }
                                            else psig
-            uh = unhashed_subpackets $ psig
+            uh = unhashed_subpackets psig
             (ns,ps) = partition isName uh
 
 fingerdress :: Packet -> SockAddr
-fingerdress topk = maybe zero id $ Hosts.inet_pton addr_str
+fingerdress topk = fromMaybe zero $ Hosts.inet_pton addr_str
  where
     zero = SockAddrInet 0 0
-    addr_str = colons $  "fd" ++ (drop 10 $ map toLower $ fingerprint topk)
+    addr_str = colons $  "fd" ++ drop 10 (map toLower $ fingerprint topk)
     colons (a:b:c:d:xs@(_:_)) = [a,b,c,d,':'] ++ colons xs
     colons xs                 = xs
 
@@ -2403,5 +2398,5 @@ backsig _                           = Nothing
 
 socketFamily :: SockAddr -> Family
 socketFamily (SockAddrInet _ _)      = AF_INET
-socketFamily (SockAddrInet6 _ _ _ _) = AF_INET6
+socketFamily (SockAddrInet6 {}) = AF_INET6
 socketFamily (SockAddrUnix _)        = AF_UNIX