summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Command/Add.hs8
-rw-r--r--Command/Uninit.hs4
-rw-r--r--Command/Unused.hs2
-rw-r--r--Git/Branch.hs15
-rw-r--r--Git/CheckAttr.hs32
-rw-r--r--Git/Command.hs26
-rw-r--r--Git/LsTree.hs21
-rw-r--r--Git/Queue.hs5
-rw-r--r--Git/Ref.hs6
-rw-r--r--Git/UnionMerge.hs13
-rw-r--r--Messages.hs13
-rw-r--r--Utility/Misc.hs8
12 files changed, 64 insertions, 89 deletions
diff --git a/Command/Add.hs b/Command/Add.hs
index 9410601b8..944525ea5 100644
--- a/Command/Add.hs
+++ b/Command/Add.hs
@@ -82,9 +82,11 @@ cleanup file key hascontent = do
-- touch the symlink to have the same mtime as the
-- file it points to
- liftIO $ do
- mtime <- modificationTime <$> getFileStatus file
- touch file (TimeSpec mtime) False
+ -- XXX Currently broken on non-utf8 locales when
+ -- dealing with utf-8 filenames.
+ --liftIO $ do
+ --mtime <- modificationTime <$> getFileStatus file
+ --touch file (TimeSpec mtime) False
force <- Annex.getState Annex.force
if force
diff --git a/Command/Uninit.hs b/Command/Uninit.hs
index 878547bc3..d6283a77d 100644
--- a/Command/Uninit.hs
+++ b/Command/Uninit.hs
@@ -7,8 +7,6 @@
module Command.Uninit where
-import qualified Data.Text.Lazy as L
-
import Common.Annex
import Command
import qualified Git
@@ -29,7 +27,7 @@ check = do
when (b == Annex.Branch.name) $ error $
"cannot uninit when the " ++ show b ++ " branch is checked out"
where
- current_branch = Git.Ref . Prelude.head . lines . L.unpack <$> revhead
+ current_branch = Git.Ref . Prelude.head . lines <$> revhead
revhead = inRepo $ Git.Command.pipeRead
[Params "rev-parse --abbrev-ref HEAD"]
diff --git a/Command/Unused.hs b/Command/Unused.hs
index 67f743ab0..1c82b9ae4 100644
--- a/Command/Unused.hs
+++ b/Command/Unused.hs
@@ -162,7 +162,7 @@ excludeReferenced l = do
refs = map (Git.Ref . snd) .
nubBy uniqref .
filter ourbranches .
- map (separate (== ' ')) . lines . L.unpack
+ map (separate (== ' ')) . lines
uniqref (a, _) (b, _) = a == b
ourbranchend = '/' : show Annex.Branch.name
ourbranches (_, b) = not $ ourbranchend `isSuffixOf` b
diff --git a/Git/Branch.hs b/Git/Branch.hs
index 546d4a96b..cd9188228 100644
--- a/Git/Branch.hs
+++ b/Git/Branch.hs
@@ -7,8 +7,6 @@
module Git.Branch where
-import qualified Data.Text.Lazy as L
-
import Common
import Git
import Git.Sha
@@ -19,15 +17,15 @@ current :: Repo -> IO (Maybe Git.Ref)
current r = parse <$> pipeRead [Param "symbolic-ref", Param "HEAD"] r
where
parse v
- | L.null v = Nothing
- | otherwise = Just $ Git.Ref $ firstLine $ L.unpack v
+ | null v = Nothing
+ | otherwise = Just $ Git.Ref $ firstLine v
{- Checks if the second branch has any commits not present on the first
- branch. -}
changed :: Branch -> Branch -> Repo -> IO Bool
changed origbranch newbranch repo
| origbranch == newbranch = return False
- | otherwise = not . L.null <$> diffs
+ | otherwise = not . null <$> diffs
where
diffs = pipeRead
[ Param "log"
@@ -73,15 +71,14 @@ fastForward branch (first:rest) repo = do
- with the specified parent refs, and returns the committed sha -}
commit :: String -> Branch -> [Ref] -> Repo -> IO Sha
commit message branch parentrefs repo = do
- tree <- getSha "write-tree" $ asString $
+ tree <- getSha "write-tree" $
pipeRead [Param "write-tree"] repo
- sha <- getSha "commit-tree" $ asString $
+ sha <- getSha "commit-tree" $
ignorehandle $ pipeWriteRead
(map Param $ ["commit-tree", show tree] ++ ps)
- (L.pack message) repo
+ message repo
run "update-ref" [Param $ show branch, Param $ show sha] repo
return sha
where
ignorehandle a = snd <$> a
- asString a = L.unpack <$> a
ps = concatMap (\r -> ["-p", show r]) parentrefs
diff --git a/Git/CheckAttr.hs b/Git/CheckAttr.hs
index eedaf6642..3e9375159 100644
--- a/Git/CheckAttr.hs
+++ b/Git/CheckAttr.hs
@@ -7,12 +7,9 @@
module Git.CheckAttr where
-import System.Exit
-
import Common
import Git
import Git.Command
-import qualified Git.Filename
import qualified Git.Version
{- Efficiently looks up a gitattributes value for each file in a list. -}
@@ -20,13 +17,9 @@ lookup :: String -> [FilePath] -> Repo -> IO [(FilePath, String)]
lookup attr files repo = do
cwd <- getCurrentDirectory
(_, fromh, toh) <- hPipeBoth "git" (toCommand params)
- _ <- forkProcess $ do
- hClose fromh
- hPutStr toh $ join "\0" $ input cwd
- hClose toh
- exitSuccess
- hClose toh
- output cwd . lines <$> hGetContents fromh
+ hPutStr toh $ join "\0" $ input cwd
+ hClose toh
+ zip files . map attrvalue . lines <$> hGetContents fromh
where
params = gitCommandLine
[ Param "check-attr"
@@ -45,22 +38,7 @@ lookup attr files repo = do
input cwd
| oldgit = map (absPathFrom cwd) files
| otherwise = map (relPathDirToFile cwd . absPathFrom cwd) files
- output cwd
- | oldgit = map (torel cwd . topair)
- | otherwise = map topair
-
- topair l = (Git.Filename.decode file, value)
- where
- file = join sep $ beginning bits
- value = end bits !! 0
+ attrvalue l = end bits !! 0
+ where
bits = split sep l
sep = ": " ++ attr ++ ": "
-
- torel cwd (file, value) = (relfile, value)
- where
- relfile
- | startswith cwd' file = drop (length cwd') file
- | otherwise = relPathDirToFile top' file
- top = workTree repo
- cwd' = cwd ++ "/"
- top' = top ++ "/"
diff --git a/Git/Command.hs b/Git/Command.hs
index 1650efe13..3d859ed28 100644
--- a/Git/Command.hs
+++ b/Git/Command.hs
@@ -8,9 +8,7 @@
module Git.Command where
import qualified Data.Text.Lazy as L
-import qualified Data.Text.Lazy.Encoding as L
import qualified Data.Text.Lazy.IO as L
-import qualified Data.ByteString.Lazy as B
import Common
import Git
@@ -41,10 +39,11 @@ run subcommand params repo = assertLocal repo $
- Note that this leaves the git process running, and so zombies will
- result unless reap is called.
-}
-pipeRead :: [CommandParam] -> Repo -> IO L.Text
+pipeRead :: [CommandParam] -> Repo -> IO String
pipeRead params repo = assertLocal repo $ do
(_, h) <- hPipeFrom "git" $ toCommand $ gitCommandLine params repo
- L.decodeUtf8 <$> B.hGetContents h
+ fileEncoding h
+ hGetContents h
{- Runs a git subcommand, feeding it input.
- You should call either getProcessStatus or forceSuccess on the PipeHandle. -}
@@ -57,26 +56,23 @@ pipeWrite params s repo = assertLocal repo $ do
{- Runs a git subcommand, feeding it input, and returning its output.
- You should call either getProcessStatus or forceSuccess on the PipeHandle. -}
-pipeWriteRead :: [CommandParam] -> L.Text -> Repo -> IO (PipeHandle, L.Text)
+pipeWriteRead :: [CommandParam] -> String -> Repo -> IO (PipeHandle, String)
pipeWriteRead params s repo = assertLocal repo $ do
(p, from, to) <- hPipeBoth "git" (toCommand $ gitCommandLine params repo)
- hSetBinaryMode from True
- L.hPutStr to s
+ fileEncoding to
+ fileEncoding from
+ hPutStr to s
hClose to
- c <- L.hGetContents from
+ c <- hGetContents from
return (p, c)
{- Reads null terminated output of a git command (as enabled by the -z
- parameter), and splits it. -}
pipeNullSplit :: [CommandParam] -> Repo -> IO [String]
-pipeNullSplit params repo = map L.unpack <$> pipeNullSplitT params repo
-
-{- For when Strings are not needed. -}
-pipeNullSplitT ::[CommandParam] -> Repo -> IO [L.Text]
-pipeNullSplitT params repo = filter (not . L.null) . L.splitOn sep <$>
- pipeRead params repo
+pipeNullSplit params repo =
+ filter (not . null) . split sep <$> pipeRead params repo
where
- sep = L.pack "\0"
+ sep = "\0"
{- Reaps any zombie git processes. -}
reap :: IO ()
diff --git a/Git/LsTree.hs b/Git/LsTree.hs
index 5c1541819..8f9066f0f 100644
--- a/Git/LsTree.hs
+++ b/Git/LsTree.hs
@@ -14,7 +14,6 @@ module Git.LsTree (
import Numeric
import Control.Applicative
import System.Posix.Types
-import qualified Data.Text.Lazy as L
import Common
import Git
@@ -31,22 +30,22 @@ data TreeItem = TreeItem
{- Lists the contents of a Ref -}
lsTree :: Ref -> Repo -> IO [TreeItem]
lsTree t repo = map parseLsTree <$>
- pipeNullSplitT [Params "ls-tree --full-tree -z -r --", File $ show t] repo
+ pipeNullSplit [Params "ls-tree --full-tree -z -r --", File $ show t] repo
{- Parses a line of ls-tree output.
- (The --long format is not currently supported.) -}
-parseLsTree :: L.Text -> TreeItem
+parseLsTree :: String -> TreeItem
parseLsTree l = TreeItem
- { mode = fst $ Prelude.head $ readOct $ L.unpack m
- , typeobj = L.unpack t
- , sha = L.unpack s
- , file = Git.Filename.decode $ L.unpack f
+ { mode = fst $ Prelude.head $ readOct m
+ , typeobj = t
+ , sha = s
+ , file = Git.Filename.decode f
}
where
-- l = <mode> SP <type> SP <sha> TAB <file>
-- All fields are fixed, so we can pull them out of
-- specific positions in the line.
- (m, past_m) = L.splitAt 7 l
- (t, past_t) = L.splitAt 4 past_m
- (s, past_s) = L.splitAt 40 $ L.tail past_t
- f = L.tail past_s
+ (m, past_m) = splitAt 7 l
+ (t, past_t) = splitAt 4 past_m
+ (s, past_s) = splitAt 40 $ Prelude.tail past_t
+ f = Prelude.tail past_s
diff --git a/Git/Queue.hs b/Git/Queue.hs
index 63c3adee7..c71605ad5 100644
--- a/Git/Queue.hs
+++ b/Git/Queue.hs
@@ -18,7 +18,6 @@ import qualified Data.Map as M
import System.IO
import System.Cmd.Utils
import Data.String.Utils
-import Codec.Binary.UTF8.String
import Utility.SafeCommand
import Common
@@ -91,4 +90,6 @@ runAction repo action files =
where
params = toCommand $ gitCommandLine
(Param (getSubcommand action):getParams action) repo
- feedxargs h = hPutStr h $ join "\0" $ map encodeString files
+ feedxargs h = do
+ fileEncoding h
+ hPutStr h $ join "\0" files
diff --git a/Git/Ref.hs b/Git/Ref.hs
index 81560b015..f483aede0 100644
--- a/Git/Ref.hs
+++ b/Git/Ref.hs
@@ -7,8 +7,6 @@
module Git.Ref where
-import qualified Data.Text.Lazy as L
-
import Common
import Git
import Git.Command
@@ -40,7 +38,7 @@ exists ref = runBool "show-ref"
{- Get the sha of a fully qualified git ref, if it exists. -}
sha :: Branch -> Repo -> IO (Maybe Sha)
-sha branch repo = process . L.unpack <$> showref repo
+sha branch repo = process <$> showref repo
where
showref = pipeRead [Param "show-ref",
Param "--hash", -- get the hash
@@ -52,7 +50,7 @@ sha branch repo = process . L.unpack <$> showref repo
matching :: Ref -> Repo -> IO [(Ref, Branch)]
matching ref repo = do
r <- pipeRead [Param "show-ref", Param $ show ref] repo
- return $ map (gen . L.unpack) (L.lines r)
+ return $ map gen (lines r)
where
gen l = let (r, b) = separate (== ' ') l in
(Ref r, Ref b)
diff --git a/Git/UnionMerge.hs b/Git/UnionMerge.hs
index 19db32860..15bff6052 100644
--- a/Git/UnionMerge.hs
+++ b/Git/UnionMerge.hs
@@ -107,21 +107,22 @@ mergeFile :: String -> FilePath -> CatFileHandle -> Repo -> IO (Maybe String)
mergeFile info file h repo = case filter (/= nullSha) [Ref asha, Ref bsha] of
[] -> return Nothing
(sha:[]) -> use sha
- shas -> use =<< either return (hashObject repo . L.unlines) =<<
+ shas -> use =<< either return (hashObject repo . unlines) =<<
calcMerge . zip shas <$> mapM getcontents shas
where
[_colonmode, _bmode, asha, bsha, _status] = words info
- getcontents s = L.lines . L.decodeUtf8 <$> catObject h s
+ getcontents s = map L.unpack . L.lines .
+ L.decodeUtf8 <$> catObject h s
use sha = return $ Just $ update_index_line sha file
{- Injects some content into git, returning its Sha. -}
-hashObject :: Repo -> L.Text -> IO Sha
+hashObject :: Repo -> String -> IO Sha
hashObject repo content = getSha subcmd $ do
(h, s) <- pipeWriteRead (map Param params) content repo
- L.length s `seq` do
+ length s `seq` do
forceSuccess h
reap -- XXX unsure why this is needed
- return $ L.unpack s
+ return s
where
subcmd = "hash-object"
params = [subcmd, "-w", "--stdin"]
@@ -131,7 +132,7 @@ hashObject repo content = getSha subcmd $ do
- When possible, reuses the content of an existing ref, rather than
- generating new content.
-}
-calcMerge :: [(Ref, [L.Text])] -> Either Ref [L.Text]
+calcMerge :: [(Ref, [String])] -> Either Ref [String]
calcMerge shacontents
| null reuseable = Right $ new
| otherwise = Left $ fst $ Prelude.head reuseable
diff --git a/Messages.hs b/Messages.hs
index ff5287d80..a0bd20ca3 100644
--- a/Messages.hs
+++ b/Messages.hs
@@ -119,16 +119,13 @@ showHeader h = handle q $
showRaw :: String -> Annex ()
showRaw s = handle q $ putStrLn s
-{- This check is done because the code assumes filenames are utf8 encoded,
- - using decodeUtf8 and Codec.Binary.UTF8.String.encodeString. So if
- - run in a non unicode locale, it will crash or worse, possibly operate
- - on the wrong file.
+{- This avoids ghc's output layer crashing on invalid encoded characters in
+ - files when printing them out.
-}
setupConsole :: IO ()
-setupConsole
- | show localeEncoding == show utf8 = return ()
- | otherwise = error $
- "Sorry, only UTF-8 locales are currently supported."
+setupConsole = do
+ fileEncoding stdout
+ fileEncoding stderr
handle :: IO () -> IO () -> Annex ()
handle json normal = Annex.getState Annex.output >>= go
diff --git a/Utility/Misc.hs b/Utility/Misc.hs
index c9bfcb953..c4992e142 100644
--- a/Utility/Misc.hs
+++ b/Utility/Misc.hs
@@ -11,6 +11,14 @@ import System.IO
import System.IO.Error (try)
import Control.Monad
import Control.Applicative
+import GHC.IO.Encoding
+
+{- Sets a Handle to use the filesystem encoding. This causes data
+ - written or read from it to be encoded/decoded the same
+ - as ghc 7.4 does to filenames et. This special encoding
+ - allows "arbitrary undecodable bytes to be round-tripped through it". -}
+fileEncoding :: Handle -> IO ()
+fileEncoding h = hSetEncoding h =<< getFileSystemEncoding
{- A version of hgetContents that is not lazy. Ensures file is
- all read before it gets closed. -}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-03 17:25:37 +0000