bb4f31a0ee
Baked into the code was an assumption that a repository's git directory could be determined by adding ".git" to its work tree (or nothing for bare repos). That fails when core.worktree, or GIT_DIR and GIT_WORK_TREE are used to separate the two. This was attacked at the type level, by storing the gitdir and worktree separately, so Nothing for the worktree means a bare repo. A complication arose because we don't learn where a repository is bare until its configuration is read. So another Location type handles repositories that have not had their config read yet. I am not entirely happy with this being a Location type, rather than representing them entirely separate from the Git type. The new code is not worse than the old, but better types could enforce more safety. Added support for core.worktree. Overriding it with -c isn't supported because it's not really clear what to do if a git repo's config is read, is not bare, and is then overridden to bare. What is the right git directory in this case? I will worry about this if/when someone has a use case for overriding core.worktree with -c. (See Git.Config.updateLocation) Also removed and renamed some functions like gitDir and workTree that misused git's terminology. One minor regression is known: git annex add in a bare repository does not print a nice error message, but runs git ls-files in a way that fails earlier with a less nice error message. This is because before --work-tree was always passed to git commands, even in a bare repo, while now it's not.
125 lines
3.6 KiB
Haskell
125 lines
3.6 KiB
Haskell
{- git repository handling
|
|
-
|
|
- This is written to be completely independant of git-annex and should be
|
|
- suitable for other uses.
|
|
-
|
|
- Copyright 2010-2012 Joey Hess <joey@kitenet.net>
|
|
-
|
|
- Licensed under the GNU GPL version 3 or higher.
|
|
-}
|
|
|
|
module Git (
|
|
Repo(..),
|
|
Ref(..),
|
|
Branch,
|
|
Sha,
|
|
Tag,
|
|
repoIsUrl,
|
|
repoIsSsh,
|
|
repoIsHttp,
|
|
repoIsLocal,
|
|
repoIsLocalBare,
|
|
repoDescribe,
|
|
repoLocation,
|
|
repoPath,
|
|
localGitDir,
|
|
attributes,
|
|
hookPath,
|
|
assertLocal,
|
|
) where
|
|
|
|
import Network.URI (uriPath, uriScheme, unEscapeString)
|
|
import System.Posix.Files
|
|
|
|
import Common
|
|
import Git.Types
|
|
import Utility.FileMode
|
|
|
|
{- User-visible description of a git repo. -}
|
|
repoDescribe :: Repo -> String
|
|
repoDescribe Repo { remoteName = Just name } = name
|
|
repoDescribe Repo { location = Url url } = show url
|
|
repoDescribe Repo { location = Local { worktree = Just dir } } = dir
|
|
repoDescribe Repo { location = Local { gitdir = dir } } = dir
|
|
repoDescribe Repo { location = LocalUnknown dir } = dir
|
|
repoDescribe Repo { location = Unknown } = "UNKNOWN"
|
|
|
|
{- Location of the repo, either as a path or url. -}
|
|
repoLocation :: Repo -> String
|
|
repoLocation Repo { location = Url url } = show url
|
|
repoLocation Repo { location = Local { worktree = Just dir } } = dir
|
|
repoLocation Repo { location = Local { gitdir = dir } } = dir
|
|
repoLocation Repo { location = LocalUnknown dir } = dir
|
|
repoLocation Repo { location = Unknown } = undefined
|
|
|
|
{- Path to a repository. For non-bare, this is the worktree, for bare,
|
|
- it's the gitdir, and for URL repositories, is the path on the remote
|
|
- host. -}
|
|
repoPath :: Repo -> FilePath
|
|
repoPath Repo { location = Url u } = unEscapeString $ uriPath u
|
|
repoPath Repo { location = Local { worktree = Just d } } = d
|
|
repoPath Repo { location = Local { gitdir = d } } = d
|
|
repoPath Repo { location = LocalUnknown dir } = dir
|
|
repoPath Repo { location = Unknown } = undefined
|
|
|
|
{- Path to a local repository's .git directory. -}
|
|
localGitDir :: Repo -> FilePath
|
|
localGitDir Repo { location = Local { gitdir = d } } = d
|
|
localGitDir _ = undefined
|
|
|
|
{- Some code needs to vary between URL and normal repos,
|
|
- or bare and non-bare, these functions help with that. -}
|
|
repoIsUrl :: Repo -> Bool
|
|
repoIsUrl Repo { location = Url _ } = True
|
|
repoIsUrl _ = False
|
|
|
|
repoIsSsh :: Repo -> Bool
|
|
repoIsSsh Repo { location = Url url }
|
|
| scheme == "ssh:" = True
|
|
-- git treats these the same as ssh
|
|
| scheme == "git+ssh:" = True
|
|
| scheme == "ssh+git:" = True
|
|
| otherwise = False
|
|
where
|
|
scheme = uriScheme url
|
|
repoIsSsh _ = False
|
|
|
|
repoIsHttp :: Repo -> Bool
|
|
repoIsHttp Repo { location = Url url }
|
|
| uriScheme url == "http:" = True
|
|
| uriScheme url == "https:" = True
|
|
| otherwise = False
|
|
repoIsHttp _ = False
|
|
|
|
repoIsLocal :: Repo -> Bool
|
|
repoIsLocal Repo { location = Local { } } = True
|
|
repoIsLocal _ = False
|
|
|
|
repoIsLocalBare :: Repo -> Bool
|
|
repoIsLocalBare Repo { location = Local { worktree = Nothing } } = True
|
|
repoIsLocalBare _ = False
|
|
|
|
assertLocal :: Repo -> a -> a
|
|
assertLocal repo action
|
|
| repoIsUrl repo = error $ unwords
|
|
[ "acting on non-local git repo"
|
|
, repoDescribe repo
|
|
, "not supported"
|
|
]
|
|
| otherwise = action
|
|
|
|
{- Path to a repository's gitattributes file. -}
|
|
attributes :: Repo -> FilePath
|
|
attributes repo
|
|
| repoIsLocalBare repo = repoPath repo ++ "/info/.gitattributes"
|
|
| otherwise = repoPath repo ++ "/.gitattributes"
|
|
|
|
{- Path to a given hook script in a repository, only if the hook exists
|
|
- and is executable. -}
|
|
hookPath :: String -> Repo -> IO (Maybe FilePath)
|
|
hookPath script repo = do
|
|
let hook = localGitDir repo </> "hooks" </> script
|
|
ifM (catchBoolIO $ isexecutable hook)
|
|
( return $ Just hook , return Nothing )
|
|
where
|
|
isexecutable f = isExecutable . fileMode <$> getFileStatus f
|