New annex.largefiles setting, which configures which files `git annex add` and the assistant add to the annex.

I would have sort of liked to put this in .gitattributes, but it seems
it does not support multi-word attribute values. Also, making this a single
config setting makes it easy to only parse the expression once.

A natural next step would be to make the assistant `git add` files that
are not annex.largefiles. OTOH, I don't think `git annex add` should
`git add` such files, because git-annex command line tools are
not in the business of wrapping git command line tools.

1 files changed, 10 insertions, 44 deletions

diff --git a/Logs/PreferredContent.hs b/Logs/PreferredContent.hs
index 3340cf5ef..0efe42e17 100644
--- a/Logs/PreferredContent.hs
+++ b/Logs/PreferredContent.hs
@@ -27,8 +27,8 @@ import qualified Annex
 import Logs.UUIDBased
 import Limit
 import qualified Utility.Matcher
+import Annex.FileMatcher
 import Annex.UUID
-import Git.FilePath
 import Types.Group
 import Logs.Group
 import Types.StandardGroups
@@ -50,19 +50,11 @@ preferredContentSet NoUUID _ = error "unknown UUID; cannot modify"
  - (or the current repository if none is specified). -}
 isPreferredContent :: Maybe UUID -> AssumeNotPresent -> FilePath -> Bool -> Annex Bool
 isPreferredContent mu notpresent file def = do
-	matchfile <- getTopFilePath <$> inRepo (toTopFilePath file)
-	let fi = Annex.FileInfo
-		{ Annex.matchFile = matchfile
-		, Annex.relFile = file
-		}
 	u <- maybe getUUID return mu
 	m <- preferredContentMap
 	case M.lookup u m of
 		Nothing -> return def
-		Just matcher
-			| Utility.Matcher.isEmpty matcher -> return def
-			| otherwise -> Utility.Matcher.matchMrun matcher $ 
-				\a -> a notpresent fi
+		Just matcher -> checkFileMatcher' matcher file notpresent def
 
 {- The map is cached for speed. -}
 preferredContentMap :: Annex Annex.PreferredContentMap
@@ -87,56 +79,30 @@ preferredContentMapRaw = simpleMap . parseLog Just
  - because the configuration is shared amoung repositories and newer
  - versions of git-annex may add new features. Instead, parse errors
  - result in a Matcher that will always succeed. -}
-makeMatcher :: GroupMap -> UUID -> String -> Utility.Matcher.Matcher MatchFiles
+makeMatcher :: GroupMap -> UUID -> String -> FileMatcher
 makeMatcher groupmap u s
 	| s == "standard" = standardMatcher groupmap u
 	| null (lefts tokens) = Utility.Matcher.generate $ rights tokens
 	| otherwise = matchAll
   where
-	tokens = map (parseToken (Just u) groupmap) (tokenizeMatcher s)
+	tokens = map (parseToken (limitPresent $ Just u) groupmap) (tokenizeMatcher s)
 
 {- Standard matchers are pre-defined for some groups. If none is defined,
  - or a repository is in multiple groups with standard matchers, match all. -}
-standardMatcher :: GroupMap -> UUID -> Utility.Matcher.Matcher MatchFiles
+standardMatcher :: GroupMap -> UUID -> FileMatcher
 standardMatcher m u = maybe matchAll (makeMatcher m u . preferredContent) $
 	getStandardGroup =<< u `M.lookup` groupsByUUID m
 
-matchAll :: Utility.Matcher.Matcher MatchFiles
-matchAll = Utility.Matcher.generate []
-
 {- Checks if an expression can be parsed, if not returns Just error -}
 checkPreferredContentExpression :: String -> Maybe String
 checkPreferredContentExpression s
 	| s == "standard" = Nothing
-	| otherwise = case lefts $ map (parseToken Nothing emptyGroupMap) (tokenizeMatcher s) of
-		[] -> Nothing
-		l -> Just $ unwords $ map ("Parse failure: " ++) l
-
-parseToken :: (Maybe UUID) -> GroupMap -> String -> Either String (Utility.Matcher.Token MatchFiles)
-parseToken mu groupmap t
-	| any (== t) Utility.Matcher.tokens = Right $ Utility.Matcher.token t
-	| t == "present" = use $ limitPresent mu
-	| otherwise = maybe (Left $ "near " ++ show t) use $ M.lookup k $
-		M.fromList
-			[ ("include", limitInclude)
-			, ("exclude", limitExclude)
-			, ("copies", limitCopies)
-			, ("inbackend", limitInBackend)
-			, ("largerthan", limitSize (>))
-			, ("smallerthan", limitSize (<))
-			, ("inallgroup", limitInAllGroup groupmap)
-			]
-  where
-	(k, v) = separate (== '=') t
-	use a = Utility.Matcher.Operation <$> a v
-
-{- This is really dumb tokenization; there's no support for quoted values.
- - Open and close parens are always treated as standalone tokens;
- - otherwise tokens must be separated by whitespace. -}
-tokenizeMatcher :: String -> [String]
-tokenizeMatcher = filter (not . null ) . concatMap splitparens . words
+	| otherwise = case parsedToMatcher vs of
+		Left e -> Just e
+		Right _ -> Nothing
   where
-	splitparens = segmentDelim (`elem` "()")
+	vs = map (parseToken (limitPresent Nothing) emptyGroupMap)
+		(tokenizeMatcher s)
 
 {- Puts a UUID in a standard group, and sets its preferred content to use
  - the standard expression for that group, unless something is already set. -}