From 67e5ad3df24cea8f16e7cb1f95e557c13b75d4ee Mon Sep 17 00:00:00 2001
From: joe <joe@jerkface.net>
Date: Fri, 18 Apr 2014 00:10:29 -0400
Subject: support --show-*

---
 KeyRing.hs |  1 +
 kiki.hs    | 81 +++++++++++++++++++-------------------------------------------
 2 files changed, 26 insertions(+), 56 deletions(-)

diff --git a/KeyRing.hs b/KeyRing.hs
index 95c348e..2f8f6ec 100644
--- a/KeyRing.hs
+++ b/KeyRing.hs
@@ -82,6 +82,7 @@ data InputFile = HomeSec
                | HomePub
                | ArgFile FilePath
                | FileDesc Posix.Fd
+ deriving (Eq,Ord)
 
 type UsageTag = String
 type Initializer = String
diff --git a/kiki.hs b/kiki.hs
index 96138c4..c29076a 100644
--- a/kiki.hs
+++ b/kiki.hs
@@ -1238,66 +1238,23 @@ main = do
     putStrLn $ "keyrings = "++show keyrings
     -}
 
-    let homespec = join . take 1 <$> Map.lookup "--homedir" margs
-    todo 
-        $ \(secfile,grip) db pubring -> do
-
-        use_db0 <- return db
-
-        let pkeypairs = maybe [] id $ do
-                            keygrip <- grip
-                            return $ map (\(spec,f,cmd)-> (parseSpec keygrip spec,f,cmd)) keypairs
-        fs <- forM pkeypairs $ \((topspec,subspec),f,cmd) -> do
-            -- Note that it's important to discard the KeyData objects
-            -- returned by filterMatches and retain only the keys.
-            -- Otherwise, the iterations within the foldM would not be
-            -- able to alter them by returning a modified KeyDB.
-            let ms = map fst $ filterMatches topspec (Map.toList db)
-            f_found <- doesFileExist f
-            return (f_found,(f,subspec,ms,cmd))
-
-
-        let (imports,exports) = partition fst fs
-        -- use_db <- foldM (doImport decrypt) use_db0 (map snd imports)
-
-        let use_db = todo
-
-        let (btcs,_) = partition isSupportedBTC btcpairs
-            isSupportedBTC (spec,"base58",cnt) = True
-            isSupportedBTC _                   = False
-            dblist = Map.toList use_db
-            pbtcs = maybe [] id $ do
-                        keygrip <- grip
-                        let conv (spec,proto,cnt) = 
-                                    let (topspec,subspec) = parseSpec keygrip spec
-                                        ms = map fst $ filterMatches topspec dblist
-                                    in (ms,subspec,cnt)
-                        return $ map conv btcs
-
-        -- use_db <- foldM (doBTCImport decrypt) use_db pbtcs
-
-        -- (ret_db,_) <- foldM (doExport decrypt) (use_db,use_db) (map snd exports)
-
-        use_db <-
-            flip (maybe $ return use_db) 
+    let auto_sign_feature rt = do
+          use_db <-
+            flip (maybe $ return (rtKeyDB rt))
                  (lookup "--autosign" $ map (\(x:xs)->(x,xs)) sargs)
                  $ \_ -> do
-                let keys = map keyPacket $ Map.elems use_db
-                    wk = workingKey grip use_db
+                let keys = map keyPacket $ Map.elems (rtKeyDB rt)
+                    wk = workingKey (rtGrip rt) (rtKeyDB rt)
                 -- g <- newGenIO
                 -- stamp <- now
                 wkun <- flip (maybe $ return Nothing) wk $ \wk -> do
                             wkun <- decrypt wk
                             maybe (error $ "Bad passphrase?") (return . Just) wkun
                 -- return . snd $ Map.mapAccum (signTorIds stamp wkun keys) g use_db
-                Traversable.mapM (signTorIds wkun keys) use_db
-
-        use_db <- markForImport margs grip pubring use_db
-
-        ret_db <- return use_db
+                Traversable.mapM (signTorIds wkun keys) (rtKeyDB rt)
+          return use_db
             
-        ret_db <- do
-            let db = ret_db
+    let doHostNames db = do
             let hns = maybe [] id $ Map.lookup "--hosts" margs
             hostdbs0 <- mapM (fmap Hosts.decode . L.readFile) hns
 
@@ -1366,9 +1323,22 @@ main = do
 
             return db'
 
-        do
-            -- On last pass, interpret --show-* commands.
-            let shspec = Map.fromList [("--show-wk", const $ show_wk secfile grip)
+    let homespec = join . take 1 <$> Map.lookup "--homedir" margs
+        kikiOp = KeyRingData
+            { kFiles = Map.fromList
+                [ ( HomeSec, (ConstRef, KeyRingFile (FileDesc 8)) )
+                , ( HomePub, (ConstRef, KeyRingFile (FileDesc 8)) )
+                ]
+            , kImports = Map.empty
+            , homeSpec = homespec
+            }
+
+    rt <- runKeyRing kikiOp 
+
+    case rt of
+      KikiResult (KikiSuccess rt) _ -> do -- interpret --show-* commands.
+            let grip = rtGrip rt
+            let shspec = Map.fromList [("--show-wk", const $ show_wk (rtSecring rt) grip)
                                       ,("--show-all",const $ show_all)
                                       ,("--show-whose-key", const $ show_whose_key input_key)
                                       ,("--show-key",\[x] -> show_key x $ maybe "" id grip)
@@ -1378,8 +1348,7 @@ main = do
                                       ,("--help", \_ _ ->kiki_usage)]
                 shargs = mapMaybe (\(x:xs) -> (,xs) <$> Map.lookup x shspec) sargs
 
-            forM_ shargs $ \(cmd,args) -> cmd args use_db
-        return ret_db
+            forM_ shargs $ \(cmd,args) -> cmd args (rtKeyDB rt)
 
     return()
  where
-- 
cgit v1.2.3