{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}
module Distribution.Client.TargetSelector
(
TargetSelector (..)
, TargetImplicitCwd (..)
, ComponentKind (..)
, ComponentKindFilter
, SubComponentTarget (..)
, QualLevel (..)
, componentKind
, readTargetSelectors
, TargetSelectorProblem (..)
, reportTargetSelectorProblems
, showTargetSelector
, TargetString (..)
, showTargetString
, parseTargetString
, readTargetSelectorsWith
, DirActions (..)
, defaultDirActions
) where
import Distribution.Client.Compat.Prelude
import Prelude ()
import Distribution.Client.Types
( PackageLocation (..)
, PackageSpecifier (..)
)
import Distribution.Package
( Package (..)
, PackageId
, PackageName
, packageName
)
import Distribution.Types.UnqualComponentName
( UnqualComponentName
, mkUnqualComponentName
, packageNameToUnqualComponentName
, unUnqualComponentName
)
import Distribution.ModuleName
( ModuleName
, toFilePath
)
import Distribution.PackageDescription
( Benchmark (..)
, BenchmarkInterface (..)
, BuildInfo (..)
, Executable (..)
, PackageDescription
, TestSuite (..)
, TestSuiteInterface (..)
, benchmarkModules
, exeModules
, explicitLibModules
, testModules
)
import Distribution.PackageDescription.Configuration
( flattenPackageDescription
)
import Distribution.Simple.LocalBuildInfo
( Component (..)
, ComponentName (..)
, LibraryName (..)
, componentBuildInfo
, componentName
, pkgComponents
)
import Distribution.Solver.Types.SourcePackage
( SourcePackage (..)
)
import Distribution.Types.ForeignLib
import Control.Arrow ((&&&))
import Control.Monad hiding
( mfilter
)
#if MIN_VERSION_base(4,20,0)
import Data.Functor as UZ (unzip)
#else
import qualified Data.List.NonEmpty as UZ (unzip)
#endif
import Data.List
( stripPrefix
)
import qualified Data.List.NonEmpty as NE
import qualified Data.Map.Lazy as Map.Lazy
import qualified Data.Map.Strict as Map
import qualified Data.Set as Set
import Distribution.Client.Errors
import Distribution.Client.Utils
( makeRelativeCanonical
)
import Distribution.Deprecated.ParseUtils
( readPToMaybe
)
import Distribution.Deprecated.ReadP
( (+++)
, (<++)
)
import qualified Distribution.Deprecated.ReadP as Parse
import Distribution.Simple.Utils
( dieWithException
, lowercase
, ordNub
)
import Distribution.Utils.Path
( getSymbolicPath
)
import qualified System.Directory as IO
( canonicalizePath
, doesDirectoryExist
, doesFileExist
, getCurrentDirectory
)
import System.FilePath
( dropExtension
, dropTrailingPathSeparator
, equalFilePath
, joinPath
, normalise
, splitDirectories
)
import qualified System.FilePath as FilePath
( splitPath
, takeExtension
, (<.>)
, (</>)
)
import Text.EditDistance
( defaultEditCosts
, restrictedDamerauLevenshteinDistance
)
import qualified Prelude (foldr1)
data TargetSelector
=
TargetPackage TargetImplicitCwd [PackageId] (Maybe ComponentKindFilter)
|
TargetPackageNamed PackageName (Maybe ComponentKindFilter)
|
TargetAllPackages (Maybe ComponentKindFilter)
|
TargetComponent PackageId ComponentName SubComponentTarget
|
TargetComponentUnknown
PackageName
(Either UnqualComponentName ComponentName)
SubComponentTarget
deriving (TargetSelector -> TargetSelector -> Bool
(TargetSelector -> TargetSelector -> Bool)
-> (TargetSelector -> TargetSelector -> Bool) -> Eq TargetSelector
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TargetSelector -> TargetSelector -> Bool
== :: TargetSelector -> TargetSelector -> Bool
$c/= :: TargetSelector -> TargetSelector -> Bool
/= :: TargetSelector -> TargetSelector -> Bool
Eq, Eq TargetSelector
Eq TargetSelector =>
(TargetSelector -> TargetSelector -> Ordering)
-> (TargetSelector -> TargetSelector -> Bool)
-> (TargetSelector -> TargetSelector -> Bool)
-> (TargetSelector -> TargetSelector -> Bool)
-> (TargetSelector -> TargetSelector -> Bool)
-> (TargetSelector -> TargetSelector -> TargetSelector)
-> (TargetSelector -> TargetSelector -> TargetSelector)
-> Ord TargetSelector
TargetSelector -> TargetSelector -> Bool
TargetSelector -> TargetSelector -> Ordering
TargetSelector -> TargetSelector -> TargetSelector
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TargetSelector -> TargetSelector -> Ordering
compare :: TargetSelector -> TargetSelector -> Ordering
$c< :: TargetSelector -> TargetSelector -> Bool
< :: TargetSelector -> TargetSelector -> Bool
$c<= :: TargetSelector -> TargetSelector -> Bool
<= :: TargetSelector -> TargetSelector -> Bool
$c> :: TargetSelector -> TargetSelector -> Bool
> :: TargetSelector -> TargetSelector -> Bool
$c>= :: TargetSelector -> TargetSelector -> Bool
>= :: TargetSelector -> TargetSelector -> Bool
$cmax :: TargetSelector -> TargetSelector -> TargetSelector
max :: TargetSelector -> TargetSelector -> TargetSelector
$cmin :: TargetSelector -> TargetSelector -> TargetSelector
min :: TargetSelector -> TargetSelector -> TargetSelector
Ord, Int -> TargetSelector -> ShowS
[TargetSelector] -> ShowS
TargetSelector -> [Char]
(Int -> TargetSelector -> ShowS)
-> (TargetSelector -> [Char])
-> ([TargetSelector] -> ShowS)
-> Show TargetSelector
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TargetSelector -> ShowS
showsPrec :: Int -> TargetSelector -> ShowS
$cshow :: TargetSelector -> [Char]
show :: TargetSelector -> [Char]
$cshowList :: [TargetSelector] -> ShowS
showList :: [TargetSelector] -> ShowS
Show, (forall x. TargetSelector -> Rep TargetSelector x)
-> (forall x. Rep TargetSelector x -> TargetSelector)
-> Generic TargetSelector
forall x. Rep TargetSelector x -> TargetSelector
forall x. TargetSelector -> Rep TargetSelector x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TargetSelector -> Rep TargetSelector x
from :: forall x. TargetSelector -> Rep TargetSelector x
$cto :: forall x. Rep TargetSelector x -> TargetSelector
to :: forall x. Rep TargetSelector x -> TargetSelector
Generic)
data TargetImplicitCwd = TargetImplicitCwd | TargetExplicitNamed
deriving (TargetImplicitCwd -> TargetImplicitCwd -> Bool
(TargetImplicitCwd -> TargetImplicitCwd -> Bool)
-> (TargetImplicitCwd -> TargetImplicitCwd -> Bool)
-> Eq TargetImplicitCwd
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
== :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
$c/= :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
/= :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
Eq, Eq TargetImplicitCwd
Eq TargetImplicitCwd =>
(TargetImplicitCwd -> TargetImplicitCwd -> Ordering)
-> (TargetImplicitCwd -> TargetImplicitCwd -> Bool)
-> (TargetImplicitCwd -> TargetImplicitCwd -> Bool)
-> (TargetImplicitCwd -> TargetImplicitCwd -> Bool)
-> (TargetImplicitCwd -> TargetImplicitCwd -> Bool)
-> (TargetImplicitCwd -> TargetImplicitCwd -> TargetImplicitCwd)
-> (TargetImplicitCwd -> TargetImplicitCwd -> TargetImplicitCwd)
-> Ord TargetImplicitCwd
TargetImplicitCwd -> TargetImplicitCwd -> Bool
TargetImplicitCwd -> TargetImplicitCwd -> Ordering
TargetImplicitCwd -> TargetImplicitCwd -> TargetImplicitCwd
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TargetImplicitCwd -> TargetImplicitCwd -> Ordering
compare :: TargetImplicitCwd -> TargetImplicitCwd -> Ordering
$c< :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
< :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
$c<= :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
<= :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
$c> :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
> :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
$c>= :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
>= :: TargetImplicitCwd -> TargetImplicitCwd -> Bool
$cmax :: TargetImplicitCwd -> TargetImplicitCwd -> TargetImplicitCwd
max :: TargetImplicitCwd -> TargetImplicitCwd -> TargetImplicitCwd
$cmin :: TargetImplicitCwd -> TargetImplicitCwd -> TargetImplicitCwd
min :: TargetImplicitCwd -> TargetImplicitCwd -> TargetImplicitCwd
Ord, Int -> TargetImplicitCwd -> ShowS
[TargetImplicitCwd] -> ShowS
TargetImplicitCwd -> [Char]
(Int -> TargetImplicitCwd -> ShowS)
-> (TargetImplicitCwd -> [Char])
-> ([TargetImplicitCwd] -> ShowS)
-> Show TargetImplicitCwd
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TargetImplicitCwd -> ShowS
showsPrec :: Int -> TargetImplicitCwd -> ShowS
$cshow :: TargetImplicitCwd -> [Char]
show :: TargetImplicitCwd -> [Char]
$cshowList :: [TargetImplicitCwd] -> ShowS
showList :: [TargetImplicitCwd] -> ShowS
Show, (forall x. TargetImplicitCwd -> Rep TargetImplicitCwd x)
-> (forall x. Rep TargetImplicitCwd x -> TargetImplicitCwd)
-> Generic TargetImplicitCwd
forall x. Rep TargetImplicitCwd x -> TargetImplicitCwd
forall x. TargetImplicitCwd -> Rep TargetImplicitCwd x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TargetImplicitCwd -> Rep TargetImplicitCwd x
from :: forall x. TargetImplicitCwd -> Rep TargetImplicitCwd x
$cto :: forall x. Rep TargetImplicitCwd x -> TargetImplicitCwd
to :: forall x. Rep TargetImplicitCwd x -> TargetImplicitCwd
Generic)
data ComponentKind = LibKind | FLibKind | ExeKind | TestKind | BenchKind
deriving (ComponentKind -> ComponentKind -> Bool
(ComponentKind -> ComponentKind -> Bool)
-> (ComponentKind -> ComponentKind -> Bool) -> Eq ComponentKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ComponentKind -> ComponentKind -> Bool
== :: ComponentKind -> ComponentKind -> Bool
$c/= :: ComponentKind -> ComponentKind -> Bool
/= :: ComponentKind -> ComponentKind -> Bool
Eq, Eq ComponentKind
Eq ComponentKind =>
(ComponentKind -> ComponentKind -> Ordering)
-> (ComponentKind -> ComponentKind -> Bool)
-> (ComponentKind -> ComponentKind -> Bool)
-> (ComponentKind -> ComponentKind -> Bool)
-> (ComponentKind -> ComponentKind -> Bool)
-> (ComponentKind -> ComponentKind -> ComponentKind)
-> (ComponentKind -> ComponentKind -> ComponentKind)
-> Ord ComponentKind
ComponentKind -> ComponentKind -> Bool
ComponentKind -> ComponentKind -> Ordering
ComponentKind -> ComponentKind -> ComponentKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ComponentKind -> ComponentKind -> Ordering
compare :: ComponentKind -> ComponentKind -> Ordering
$c< :: ComponentKind -> ComponentKind -> Bool
< :: ComponentKind -> ComponentKind -> Bool
$c<= :: ComponentKind -> ComponentKind -> Bool
<= :: ComponentKind -> ComponentKind -> Bool
$c> :: ComponentKind -> ComponentKind -> Bool
> :: ComponentKind -> ComponentKind -> Bool
$c>= :: ComponentKind -> ComponentKind -> Bool
>= :: ComponentKind -> ComponentKind -> Bool
$cmax :: ComponentKind -> ComponentKind -> ComponentKind
max :: ComponentKind -> ComponentKind -> ComponentKind
$cmin :: ComponentKind -> ComponentKind -> ComponentKind
min :: ComponentKind -> ComponentKind -> ComponentKind
Ord, Int -> ComponentKind
ComponentKind -> Int
ComponentKind -> [ComponentKind]
ComponentKind -> ComponentKind
ComponentKind -> ComponentKind -> [ComponentKind]
ComponentKind -> ComponentKind -> ComponentKind -> [ComponentKind]
(ComponentKind -> ComponentKind)
-> (ComponentKind -> ComponentKind)
-> (Int -> ComponentKind)
-> (ComponentKind -> Int)
-> (ComponentKind -> [ComponentKind])
-> (ComponentKind -> ComponentKind -> [ComponentKind])
-> (ComponentKind -> ComponentKind -> [ComponentKind])
-> (ComponentKind
-> ComponentKind -> ComponentKind -> [ComponentKind])
-> Enum ComponentKind
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ComponentKind -> ComponentKind
succ :: ComponentKind -> ComponentKind
$cpred :: ComponentKind -> ComponentKind
pred :: ComponentKind -> ComponentKind
$ctoEnum :: Int -> ComponentKind
toEnum :: Int -> ComponentKind
$cfromEnum :: ComponentKind -> Int
fromEnum :: ComponentKind -> Int
$cenumFrom :: ComponentKind -> [ComponentKind]
enumFrom :: ComponentKind -> [ComponentKind]
$cenumFromThen :: ComponentKind -> ComponentKind -> [ComponentKind]
enumFromThen :: ComponentKind -> ComponentKind -> [ComponentKind]
$cenumFromTo :: ComponentKind -> ComponentKind -> [ComponentKind]
enumFromTo :: ComponentKind -> ComponentKind -> [ComponentKind]
$cenumFromThenTo :: ComponentKind -> ComponentKind -> ComponentKind -> [ComponentKind]
enumFromThenTo :: ComponentKind -> ComponentKind -> ComponentKind -> [ComponentKind]
Enum, Int -> ComponentKind -> ShowS
[ComponentKind] -> ShowS
ComponentKind -> [Char]
(Int -> ComponentKind -> ShowS)
-> (ComponentKind -> [Char])
-> ([ComponentKind] -> ShowS)
-> Show ComponentKind
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ComponentKind -> ShowS
showsPrec :: Int -> ComponentKind -> ShowS
$cshow :: ComponentKind -> [Char]
show :: ComponentKind -> [Char]
$cshowList :: [ComponentKind] -> ShowS
showList :: [ComponentKind] -> ShowS
Show)
type ComponentKindFilter = ComponentKind
data SubComponentTarget
=
WholeComponent
|
ModuleTarget ModuleName
|
FileTarget FilePath
deriving (SubComponentTarget -> SubComponentTarget -> Bool
(SubComponentTarget -> SubComponentTarget -> Bool)
-> (SubComponentTarget -> SubComponentTarget -> Bool)
-> Eq SubComponentTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubComponentTarget -> SubComponentTarget -> Bool
== :: SubComponentTarget -> SubComponentTarget -> Bool
$c/= :: SubComponentTarget -> SubComponentTarget -> Bool
/= :: SubComponentTarget -> SubComponentTarget -> Bool
Eq, Eq SubComponentTarget
Eq SubComponentTarget =>
(SubComponentTarget -> SubComponentTarget -> Ordering)
-> (SubComponentTarget -> SubComponentTarget -> Bool)
-> (SubComponentTarget -> SubComponentTarget -> Bool)
-> (SubComponentTarget -> SubComponentTarget -> Bool)
-> (SubComponentTarget -> SubComponentTarget -> Bool)
-> (SubComponentTarget -> SubComponentTarget -> SubComponentTarget)
-> (SubComponentTarget -> SubComponentTarget -> SubComponentTarget)
-> Ord SubComponentTarget
SubComponentTarget -> SubComponentTarget -> Bool
SubComponentTarget -> SubComponentTarget -> Ordering
SubComponentTarget -> SubComponentTarget -> SubComponentTarget
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SubComponentTarget -> SubComponentTarget -> Ordering
compare :: SubComponentTarget -> SubComponentTarget -> Ordering
$c< :: SubComponentTarget -> SubComponentTarget -> Bool
< :: SubComponentTarget -> SubComponentTarget -> Bool
$c<= :: SubComponentTarget -> SubComponentTarget -> Bool
<= :: SubComponentTarget -> SubComponentTarget -> Bool
$c> :: SubComponentTarget -> SubComponentTarget -> Bool
> :: SubComponentTarget -> SubComponentTarget -> Bool
$c>= :: SubComponentTarget -> SubComponentTarget -> Bool
>= :: SubComponentTarget -> SubComponentTarget -> Bool
$cmax :: SubComponentTarget -> SubComponentTarget -> SubComponentTarget
max :: SubComponentTarget -> SubComponentTarget -> SubComponentTarget
$cmin :: SubComponentTarget -> SubComponentTarget -> SubComponentTarget
min :: SubComponentTarget -> SubComponentTarget -> SubComponentTarget
Ord, Int -> SubComponentTarget -> ShowS
[SubComponentTarget] -> ShowS
SubComponentTarget -> [Char]
(Int -> SubComponentTarget -> ShowS)
-> (SubComponentTarget -> [Char])
-> ([SubComponentTarget] -> ShowS)
-> Show SubComponentTarget
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubComponentTarget -> ShowS
showsPrec :: Int -> SubComponentTarget -> ShowS
$cshow :: SubComponentTarget -> [Char]
show :: SubComponentTarget -> [Char]
$cshowList :: [SubComponentTarget] -> ShowS
showList :: [SubComponentTarget] -> ShowS
Show, (forall x. SubComponentTarget -> Rep SubComponentTarget x)
-> (forall x. Rep SubComponentTarget x -> SubComponentTarget)
-> Generic SubComponentTarget
forall x. Rep SubComponentTarget x -> SubComponentTarget
forall x. SubComponentTarget -> Rep SubComponentTarget x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SubComponentTarget -> Rep SubComponentTarget x
from :: forall x. SubComponentTarget -> Rep SubComponentTarget x
$cto :: forall x. Rep SubComponentTarget x -> SubComponentTarget
to :: forall x. Rep SubComponentTarget x -> SubComponentTarget
Generic)
instance Binary SubComponentTarget
instance Structured SubComponentTarget
readTargetSelectors
:: [PackageSpecifier (SourcePackage (PackageLocation a))]
-> Maybe ComponentKindFilter
-> [String]
-> IO (Either [TargetSelectorProblem] [TargetSelector])
readTargetSelectors :: forall a.
[PackageSpecifier (SourcePackage (PackageLocation a))]
-> Maybe ComponentKind
-> [[Char]]
-> IO (Either [TargetSelectorProblem] [TargetSelector])
readTargetSelectors = DirActions IO
-> [PackageSpecifier (SourcePackage (PackageLocation a))]
-> Maybe ComponentKind
-> [[Char]]
-> IO (Either [TargetSelectorProblem] [TargetSelector])
forall (m :: * -> *) a.
(Applicative m, Monad m) =>
DirActions m
-> [PackageSpecifier (SourcePackage (PackageLocation a))]
-> Maybe ComponentKind
-> [[Char]]
-> m (Either [TargetSelectorProblem] [TargetSelector])
readTargetSelectorsWith DirActions IO
defaultDirActions
readTargetSelectorsWith
:: (Applicative m, Monad m)
=> DirActions m
-> [PackageSpecifier (SourcePackage (PackageLocation a))]
-> Maybe ComponentKindFilter
-> [String]
-> m (Either [TargetSelectorProblem] [TargetSelector])
readTargetSelectorsWith :: forall (m :: * -> *) a.
(Applicative m, Monad m) =>
DirActions m
-> [PackageSpecifier (SourcePackage (PackageLocation a))]
-> Maybe ComponentKind
-> [[Char]]
-> m (Either [TargetSelectorProblem] [TargetSelector])
readTargetSelectorsWith dirActions :: DirActions m
dirActions@DirActions{} [PackageSpecifier (SourcePackage (PackageLocation a))]
pkgs Maybe ComponentKind
mfilter [[Char]]
targetStrs =
case [[Char]] -> ([[Char]], [TargetString])
parseTargetStrings [[Char]]
targetStrs of
([], [TargetString]
usertargets) -> do
usertargets' <- (TargetString -> m TargetStringFileStatus)
-> [TargetString] -> m [TargetStringFileStatus]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (DirActions m -> TargetString -> m TargetStringFileStatus
forall (m :: * -> *).
(Applicative m, Monad m) =>
DirActions m -> TargetString -> m TargetStringFileStatus
getTargetStringFileStatus DirActions m
dirActions) [TargetString]
usertargets
knowntargets <- getKnownTargets dirActions pkgs
case resolveTargetSelectors knowntargets usertargets' mfilter of
([], [TargetSelector]
btargets) -> Either [TargetSelectorProblem] [TargetSelector]
-> m (Either [TargetSelectorProblem] [TargetSelector])
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([TargetSelector] -> Either [TargetSelectorProblem] [TargetSelector]
forall a b. b -> Either a b
Right [TargetSelector]
btargets)
([TargetSelectorProblem]
problems, [TargetSelector]
_) -> Either [TargetSelectorProblem] [TargetSelector]
-> m (Either [TargetSelectorProblem] [TargetSelector])
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([TargetSelectorProblem]
-> Either [TargetSelectorProblem] [TargetSelector]
forall a b. a -> Either a b
Left [TargetSelectorProblem]
problems)
([[Char]]
strs, [TargetString]
_) -> Either [TargetSelectorProblem] [TargetSelector]
-> m (Either [TargetSelectorProblem] [TargetSelector])
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([TargetSelectorProblem]
-> Either [TargetSelectorProblem] [TargetSelector]
forall a b. a -> Either a b
Left (([Char] -> TargetSelectorProblem)
-> [[Char]] -> [TargetSelectorProblem]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> TargetSelectorProblem
TargetSelectorUnrecognised [[Char]]
strs))
data DirActions m = DirActions
{ forall (m :: * -> *). DirActions m -> [Char] -> m Bool
doesFileExist :: FilePath -> m Bool
, forall (m :: * -> *). DirActions m -> [Char] -> m Bool
doesDirectoryExist :: FilePath -> m Bool
, forall (m :: * -> *). DirActions m -> [Char] -> m [Char]
canonicalizePath :: FilePath -> m FilePath
, forall (m :: * -> *). DirActions m -> m [Char]
getCurrentDirectory :: m FilePath
}
defaultDirActions :: DirActions IO
defaultDirActions :: DirActions IO
defaultDirActions =
DirActions
{ doesFileExist :: [Char] -> IO Bool
doesFileExist = [Char] -> IO Bool
IO.doesFileExist
, doesDirectoryExist :: [Char] -> IO Bool
doesDirectoryExist = [Char] -> IO Bool
IO.doesDirectoryExist
,
canonicalizePath :: [Char] -> IO [Char]
canonicalizePath = [Char] -> IO [Char]
IO.canonicalizePath ([Char] -> IO [Char]) -> ShowS -> [Char] -> IO [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
dropTrailingPathSeparator
, getCurrentDirectory :: IO [Char]
getCurrentDirectory = IO [Char]
IO.getCurrentDirectory
}
makeRelativeToCwd :: Applicative m => DirActions m -> FilePath -> m FilePath
makeRelativeToCwd :: forall (m :: * -> *).
Applicative m =>
DirActions m -> [Char] -> m [Char]
makeRelativeToCwd DirActions{m [Char]
[Char] -> m Bool
[Char] -> m [Char]
doesFileExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
doesDirectoryExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
canonicalizePath :: forall (m :: * -> *). DirActions m -> [Char] -> m [Char]
getCurrentDirectory :: forall (m :: * -> *). DirActions m -> m [Char]
doesFileExist :: [Char] -> m Bool
doesDirectoryExist :: [Char] -> m Bool
canonicalizePath :: [Char] -> m [Char]
getCurrentDirectory :: m [Char]
..} [Char]
path =
[Char] -> ShowS
makeRelativeCanonical ([Char] -> ShowS) -> m [Char] -> m ShowS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> m [Char]
canonicalizePath [Char]
path m ShowS -> m [Char] -> m [Char]
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m [Char]
getCurrentDirectory
data TargetString
= TargetString1 String
| TargetString2 String String
| TargetString3 String String String
| TargetString4 String String String String
| TargetString5 String String String String String
| TargetString7 String String String String String String String
deriving (Int -> TargetString -> ShowS
[TargetString] -> ShowS
TargetString -> [Char]
(Int -> TargetString -> ShowS)
-> (TargetString -> [Char])
-> ([TargetString] -> ShowS)
-> Show TargetString
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TargetString -> ShowS
showsPrec :: Int -> TargetString -> ShowS
$cshow :: TargetString -> [Char]
show :: TargetString -> [Char]
$cshowList :: [TargetString] -> ShowS
showList :: [TargetString] -> ShowS
Show, TargetString -> TargetString -> Bool
(TargetString -> TargetString -> Bool)
-> (TargetString -> TargetString -> Bool) -> Eq TargetString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TargetString -> TargetString -> Bool
== :: TargetString -> TargetString -> Bool
$c/= :: TargetString -> TargetString -> Bool
/= :: TargetString -> TargetString -> Bool
Eq)
parseTargetStrings :: [String] -> ([String], [TargetString])
parseTargetStrings :: [[Char]] -> ([[Char]], [TargetString])
parseTargetStrings =
[Either [Char] TargetString] -> ([[Char]], [TargetString])
forall a b. [Either a b] -> ([a], [b])
partitionEithers
([Either [Char] TargetString] -> ([[Char]], [TargetString]))
-> ([[Char]] -> [Either [Char] TargetString])
-> [[Char]]
-> ([[Char]], [TargetString])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Either [Char] TargetString)
-> [[Char]] -> [Either [Char] TargetString]
forall a b. (a -> b) -> [a] -> [b]
map (\[Char]
str -> Either [Char] TargetString
-> (TargetString -> Either [Char] TargetString)
-> Maybe TargetString
-> Either [Char] TargetString
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> Either [Char] TargetString
forall a b. a -> Either a b
Left [Char]
str) TargetString -> Either [Char] TargetString
forall a b. b -> Either a b
Right ([Char] -> Maybe TargetString
parseTargetString [Char]
str))
parseTargetString :: String -> Maybe TargetString
parseTargetString :: [Char] -> Maybe TargetString
parseTargetString =
ReadP TargetString TargetString -> [Char] -> Maybe TargetString
forall a. ReadP a a -> [Char] -> Maybe a
readPToMaybe ReadP TargetString TargetString
forall r. ReadP r TargetString
parseTargetApprox
where
parseTargetApprox :: Parse.ReadP r TargetString
parseTargetApprox :: forall r. ReadP r TargetString
parseTargetApprox =
( do
a <- ReadP r [Char]
forall {r}. ReadP r [Char]
tokenQEnd
return (TargetString1 a)
)
Parser r Char TargetString
-> Parser r Char TargetString -> Parser r Char TargetString
forall r a. ReadP r a -> ReadP r a -> ReadP r a
+++ ( do
a <- ReadP r [Char]
forall {r}. ReadP r [Char]
tokenQ0
_ <- Parse.char ':'
b <- tokenQEnd
return (TargetString2 a b)
)
Parser r Char TargetString
-> Parser r Char TargetString -> Parser r Char TargetString
forall r a. ReadP r a -> ReadP r a -> ReadP r a
+++ ( do
a <- ReadP r [Char]
forall {r}. ReadP r [Char]
tokenQ0
_ <- Parse.char ':'
b <- tokenQ
_ <- Parse.char ':'
c <- tokenQEnd
return (TargetString3 a b c)
)
Parser r Char TargetString
-> Parser r Char TargetString -> Parser r Char TargetString
forall r a. ReadP r a -> ReadP r a -> ReadP r a
+++ ( do
a <- ReadP r [Char]
forall {r}. ReadP r [Char]
tokenQ0
_ <- Parse.char ':'
b <- token
_ <- Parse.char ':'
c <- tokenQ
_ <- Parse.char ':'
d <- tokenQEnd
return (TargetString4 a b c d)
)
Parser r Char TargetString
-> Parser r Char TargetString -> Parser r Char TargetString
forall r a. ReadP r a -> ReadP r a -> ReadP r a
+++ ( do
a <- ReadP r [Char]
forall {r}. ReadP r [Char]
tokenQ0
_ <- Parse.char ':'
b <- token
_ <- Parse.char ':'
c <- tokenQ
_ <- Parse.char ':'
d <- tokenQ
_ <- Parse.char ':'
e <- tokenQEnd
return (TargetString5 a b c d e)
)
Parser r Char TargetString
-> Parser r Char TargetString -> Parser r Char TargetString
forall r a. ReadP r a -> ReadP r a -> ReadP r a
+++ ( do
a <- ReadP r [Char]
forall {r}. ReadP r [Char]
tokenQ0
_ <- Parse.char ':'
b <- token
_ <- Parse.char ':'
c <- tokenQ
_ <- Parse.char ':'
d <- tokenQ
_ <- Parse.char ':'
e <- tokenQ
_ <- Parse.char ':'
f <- tokenQ
_ <- Parse.char ':'
g <- tokenQEnd
return (TargetString7 a b c d e f g)
)
token :: ReadP r [Char]
token = (Char -> Bool) -> ReadP r [Char]
forall r. (Char -> Bool) -> ReadP r [Char]
Parse.munch1 (\Char
x -> Bool -> Bool
not (Char -> Bool
isSpace Char
x) Bool -> Bool -> Bool
&& Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
':')
tokenQ :: ReadP r [Char]
tokenQ = ReadP [Char] [Char]
forall {r}. ReadP r [Char]
parseHaskellString ReadP [Char] [Char] -> ReadP r [Char] -> ReadP r [Char]
forall a r. ReadP a a -> ReadP r a -> ReadP r a
<++ ReadP r [Char]
forall {r}. ReadP r [Char]
token
token0 :: ReadP r [Char]
token0 = (Char -> Bool) -> ReadP r [Char]
forall r. (Char -> Bool) -> ReadP r [Char]
Parse.munch (\Char
x -> Bool -> Bool
not (Char -> Bool
isSpace Char
x) Bool -> Bool -> Bool
&& Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
':')
tokenQ0 :: ReadP r [Char]
tokenQ0 = ReadP [Char] [Char]
forall {r}. ReadP r [Char]
parseHaskellString ReadP [Char] [Char] -> ReadP r [Char] -> ReadP r [Char]
forall a r. ReadP a a -> ReadP r a -> ReadP r a
<++ ReadP r [Char]
forall {r}. ReadP r [Char]
token0
tokenEnd :: ReadP r [Char]
tokenEnd = (Char -> Bool) -> ReadP r [Char]
forall r. (Char -> Bool) -> ReadP r [Char]
Parse.munch1 (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
':')
tokenQEnd :: ReadP r [Char]
tokenQEnd = ReadP [Char] [Char]
forall {r}. ReadP r [Char]
parseHaskellString ReadP [Char] [Char] -> ReadP r [Char] -> ReadP r [Char]
forall a r. ReadP a a -> ReadP r a -> ReadP r a
<++ ReadP r [Char]
forall {r}. ReadP r [Char]
tokenEnd
parseHaskellString :: Parse.ReadP r String
parseHaskellString :: forall {r}. ReadP r [Char]
parseHaskellString = ReadS [Char] -> ReadP r [Char]
forall a r. ReadS a -> ReadP r a
Parse.readS_to_P ReadS [Char]
forall a. Read a => ReadS a
reads
showTargetString :: TargetString -> String
showTargetString :: TargetString -> [Char]
showTargetString = [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
":" ([[Char]] -> [Char])
-> (TargetString -> [[Char]]) -> TargetString -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TargetString -> [[Char]]
components
where
components :: TargetString -> [[Char]]
components (TargetString1 [Char]
s1) = [[Char]
s1]
components (TargetString2 [Char]
s1 [Char]
s2) = [[Char]
s1, [Char]
s2]
components (TargetString3 [Char]
s1 [Char]
s2 [Char]
s3) = [[Char]
s1, [Char]
s2, [Char]
s3]
components (TargetString4 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4) = [[Char]
s1, [Char]
s2, [Char]
s3, [Char]
s4]
components (TargetString5 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 [Char]
s5) = [[Char]
s1, [Char]
s2, [Char]
s3, [Char]
s4, [Char]
s5]
components (TargetString7 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 [Char]
s5 [Char]
s6 [Char]
s7) = [[Char]
s1, [Char]
s2, [Char]
s3, [Char]
s4, [Char]
s5, [Char]
s6, [Char]
s7]
showTargetSelector :: TargetSelector -> String
showTargetSelector :: TargetSelector -> [Char]
showTargetSelector TargetSelector
ts =
case [ TargetStringFileStatus
t | QualLevel
ql <- [QualLevel
QL1 .. QualLevel
QLFull], TargetStringFileStatus
t <- QualLevel -> TargetSelector -> [TargetStringFileStatus]
renderTargetSelector QualLevel
ql TargetSelector
ts
] of
(TargetStringFileStatus
t' : [TargetStringFileStatus]
_) -> TargetString -> [Char]
showTargetString (TargetStringFileStatus -> TargetString
forgetFileStatus TargetStringFileStatus
t')
[] -> [Char]
""
showTargetSelectorKind :: TargetSelector -> String
showTargetSelectorKind :: TargetSelector -> [Char]
showTargetSelectorKind TargetSelector
bt = case TargetSelector
bt of
TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier]
_ Maybe ComponentKind
Nothing -> [Char]
"package"
TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier]
_ (Just ComponentKind
_) -> [Char]
"package:filter"
TargetPackage TargetImplicitCwd
TargetImplicitCwd [PackageIdentifier]
_ Maybe ComponentKind
Nothing -> [Char]
"cwd-package"
TargetPackage TargetImplicitCwd
TargetImplicitCwd [PackageIdentifier]
_ (Just ComponentKind
_) -> [Char]
"cwd-package:filter"
TargetPackageNamed PackageName
_ Maybe ComponentKind
Nothing -> [Char]
"named-package"
TargetPackageNamed PackageName
_ (Just ComponentKind
_) -> [Char]
"named-package:filter"
TargetAllPackages Maybe ComponentKind
Nothing -> [Char]
"package *"
TargetAllPackages (Just ComponentKind
_) -> [Char]
"package *:filter"
TargetComponent PackageIdentifier
_ ComponentName
_ SubComponentTarget
WholeComponent -> [Char]
"component"
TargetComponent PackageIdentifier
_ ComponentName
_ ModuleTarget{} -> [Char]
"module"
TargetComponent PackageIdentifier
_ ComponentName
_ FileTarget{} -> [Char]
"file"
TargetComponentUnknown PackageName
_ Either UnqualComponentName ComponentName
_ SubComponentTarget
WholeComponent -> [Char]
"unknown-component"
TargetComponentUnknown PackageName
_ Either UnqualComponentName ComponentName
_ ModuleTarget{} -> [Char]
"unknown-module"
TargetComponentUnknown PackageName
_ Either UnqualComponentName ComponentName
_ FileTarget{} -> [Char]
"unknown-file"
data TargetStringFileStatus
= TargetStringFileStatus1 String FileStatus
| TargetStringFileStatus2 String FileStatus String
| TargetStringFileStatus3 String FileStatus String String
| TargetStringFileStatus4 String String String String
| TargetStringFileStatus5 String String String String String
| TargetStringFileStatus7 String String String String String String String
deriving (TargetStringFileStatus -> TargetStringFileStatus -> Bool
(TargetStringFileStatus -> TargetStringFileStatus -> Bool)
-> (TargetStringFileStatus -> TargetStringFileStatus -> Bool)
-> Eq TargetStringFileStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
== :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
$c/= :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
/= :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
Eq, Eq TargetStringFileStatus
Eq TargetStringFileStatus =>
(TargetStringFileStatus -> TargetStringFileStatus -> Ordering)
-> (TargetStringFileStatus -> TargetStringFileStatus -> Bool)
-> (TargetStringFileStatus -> TargetStringFileStatus -> Bool)
-> (TargetStringFileStatus -> TargetStringFileStatus -> Bool)
-> (TargetStringFileStatus -> TargetStringFileStatus -> Bool)
-> (TargetStringFileStatus
-> TargetStringFileStatus -> TargetStringFileStatus)
-> (TargetStringFileStatus
-> TargetStringFileStatus -> TargetStringFileStatus)
-> Ord TargetStringFileStatus
TargetStringFileStatus -> TargetStringFileStatus -> Bool
TargetStringFileStatus -> TargetStringFileStatus -> Ordering
TargetStringFileStatus
-> TargetStringFileStatus -> TargetStringFileStatus
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TargetStringFileStatus -> TargetStringFileStatus -> Ordering
compare :: TargetStringFileStatus -> TargetStringFileStatus -> Ordering
$c< :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
< :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
$c<= :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
<= :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
$c> :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
> :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
$c>= :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
>= :: TargetStringFileStatus -> TargetStringFileStatus -> Bool
$cmax :: TargetStringFileStatus
-> TargetStringFileStatus -> TargetStringFileStatus
max :: TargetStringFileStatus
-> TargetStringFileStatus -> TargetStringFileStatus
$cmin :: TargetStringFileStatus
-> TargetStringFileStatus -> TargetStringFileStatus
min :: TargetStringFileStatus
-> TargetStringFileStatus -> TargetStringFileStatus
Ord, Int -> TargetStringFileStatus -> ShowS
[TargetStringFileStatus] -> ShowS
TargetStringFileStatus -> [Char]
(Int -> TargetStringFileStatus -> ShowS)
-> (TargetStringFileStatus -> [Char])
-> ([TargetStringFileStatus] -> ShowS)
-> Show TargetStringFileStatus
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TargetStringFileStatus -> ShowS
showsPrec :: Int -> TargetStringFileStatus -> ShowS
$cshow :: TargetStringFileStatus -> [Char]
show :: TargetStringFileStatus -> [Char]
$cshowList :: [TargetStringFileStatus] -> ShowS
showList :: [TargetStringFileStatus] -> ShowS
Show)
data FileStatus
= FileStatusExistsFile FilePath
| FileStatusExistsDir FilePath
| FileStatusNotExists Bool
deriving (FileStatus -> FileStatus -> Bool
(FileStatus -> FileStatus -> Bool)
-> (FileStatus -> FileStatus -> Bool) -> Eq FileStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FileStatus -> FileStatus -> Bool
== :: FileStatus -> FileStatus -> Bool
$c/= :: FileStatus -> FileStatus -> Bool
/= :: FileStatus -> FileStatus -> Bool
Eq, Eq FileStatus
Eq FileStatus =>
(FileStatus -> FileStatus -> Ordering)
-> (FileStatus -> FileStatus -> Bool)
-> (FileStatus -> FileStatus -> Bool)
-> (FileStatus -> FileStatus -> Bool)
-> (FileStatus -> FileStatus -> Bool)
-> (FileStatus -> FileStatus -> FileStatus)
-> (FileStatus -> FileStatus -> FileStatus)
-> Ord FileStatus
FileStatus -> FileStatus -> Bool
FileStatus -> FileStatus -> Ordering
FileStatus -> FileStatus -> FileStatus
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FileStatus -> FileStatus -> Ordering
compare :: FileStatus -> FileStatus -> Ordering
$c< :: FileStatus -> FileStatus -> Bool
< :: FileStatus -> FileStatus -> Bool
$c<= :: FileStatus -> FileStatus -> Bool
<= :: FileStatus -> FileStatus -> Bool
$c> :: FileStatus -> FileStatus -> Bool
> :: FileStatus -> FileStatus -> Bool
$c>= :: FileStatus -> FileStatus -> Bool
>= :: FileStatus -> FileStatus -> Bool
$cmax :: FileStatus -> FileStatus -> FileStatus
max :: FileStatus -> FileStatus -> FileStatus
$cmin :: FileStatus -> FileStatus -> FileStatus
min :: FileStatus -> FileStatus -> FileStatus
Ord, Int -> FileStatus -> ShowS
[FileStatus] -> ShowS
FileStatus -> [Char]
(Int -> FileStatus -> ShowS)
-> (FileStatus -> [Char])
-> ([FileStatus] -> ShowS)
-> Show FileStatus
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FileStatus -> ShowS
showsPrec :: Int -> FileStatus -> ShowS
$cshow :: FileStatus -> [Char]
show :: FileStatus -> [Char]
$cshowList :: [FileStatus] -> ShowS
showList :: [FileStatus] -> ShowS
Show)
noFileStatus :: FileStatus
noFileStatus :: FileStatus
noFileStatus = Bool -> FileStatus
FileStatusNotExists Bool
False
getTargetStringFileStatus
:: (Applicative m, Monad m)
=> DirActions m
-> TargetString
-> m TargetStringFileStatus
getTargetStringFileStatus :: forall (m :: * -> *).
(Applicative m, Monad m) =>
DirActions m -> TargetString -> m TargetStringFileStatus
getTargetStringFileStatus DirActions{m [Char]
[Char] -> m Bool
[Char] -> m [Char]
doesFileExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
doesDirectoryExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
canonicalizePath :: forall (m :: * -> *). DirActions m -> [Char] -> m [Char]
getCurrentDirectory :: forall (m :: * -> *). DirActions m -> m [Char]
doesFileExist :: [Char] -> m Bool
doesDirectoryExist :: [Char] -> m Bool
canonicalizePath :: [Char] -> m [Char]
getCurrentDirectory :: m [Char]
..} TargetString
t =
case TargetString
t of
TargetString1 [Char]
s1 ->
(\FileStatus
f1 -> [Char] -> FileStatus -> TargetStringFileStatus
TargetStringFileStatus1 [Char]
s1 FileStatus
f1) (FileStatus -> TargetStringFileStatus)
-> m FileStatus -> m TargetStringFileStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> m FileStatus
fileStatus [Char]
s1
TargetString2 [Char]
s1 [Char]
s2 ->
(\FileStatus
f1 -> [Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 [Char]
s1 FileStatus
f1 [Char]
s2) (FileStatus -> TargetStringFileStatus)
-> m FileStatus -> m TargetStringFileStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> m FileStatus
fileStatus [Char]
s1
TargetString3 [Char]
s1 [Char]
s2 [Char]
s3 ->
(\FileStatus
f1 -> [Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 [Char]
s1 FileStatus
f1 [Char]
s2 [Char]
s3) (FileStatus -> TargetStringFileStatus)
-> m FileStatus -> m TargetStringFileStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> m FileStatus
fileStatus [Char]
s1
TargetString4 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 ->
TargetStringFileStatus -> m TargetStringFileStatus
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> [Char] -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus4 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4)
TargetString5 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 [Char]
s5 ->
TargetStringFileStatus -> m TargetStringFileStatus
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char]
-> [Char] -> [Char] -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus5 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 [Char]
s5)
TargetString7 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 [Char]
s5 [Char]
s6 [Char]
s7 ->
TargetStringFileStatus -> m TargetStringFileStatus
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> TargetStringFileStatus
TargetStringFileStatus7 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 [Char]
s5 [Char]
s6 [Char]
s7)
where
fileStatus :: [Char] -> m FileStatus
fileStatus [Char]
f = do
fexists <- [Char] -> m Bool
doesFileExist [Char]
f
dexists <- doesDirectoryExist f
case FilePath.splitPath f of
[[Char]]
_
| Bool
fexists -> [Char] -> FileStatus
FileStatusExistsFile ([Char] -> FileStatus) -> m [Char] -> m FileStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> m [Char]
canonicalizePath [Char]
f
| Bool
dexists -> [Char] -> FileStatus
FileStatusExistsDir ([Char] -> FileStatus) -> m [Char] -> m FileStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> m [Char]
canonicalizePath [Char]
f
([Char]
d : [[Char]]
_) -> Bool -> FileStatus
FileStatusNotExists (Bool -> FileStatus) -> m Bool -> m FileStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> m Bool
doesDirectoryExist [Char]
d
[[Char]]
_ -> FileStatus -> m FileStatus
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> FileStatus
FileStatusNotExists Bool
False)
forgetFileStatus :: TargetStringFileStatus -> TargetString
forgetFileStatus :: TargetStringFileStatus -> TargetString
forgetFileStatus TargetStringFileStatus
t = case TargetStringFileStatus
t of
TargetStringFileStatus1 [Char]
s1 FileStatus
_ -> [Char] -> TargetString
TargetString1 [Char]
s1
TargetStringFileStatus2 [Char]
s1 FileStatus
_ [Char]
s2 -> [Char] -> [Char] -> TargetString
TargetString2 [Char]
s1 [Char]
s2
TargetStringFileStatus3 [Char]
s1 FileStatus
_ [Char]
s2 [Char]
s3 -> [Char] -> [Char] -> [Char] -> TargetString
TargetString3 [Char]
s1 [Char]
s2 [Char]
s3
TargetStringFileStatus4 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 -> [Char] -> [Char] -> [Char] -> [Char] -> TargetString
TargetString4 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4
TargetStringFileStatus5
[Char]
s1
[Char]
s2
[Char]
s3
[Char]
s4
[Char]
s5 -> [Char] -> [Char] -> [Char] -> [Char] -> [Char] -> TargetString
TargetString5 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 [Char]
s5
TargetStringFileStatus7
[Char]
s1
[Char]
s2
[Char]
s3
[Char]
s4
[Char]
s5
[Char]
s6
[Char]
s7 -> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> TargetString
TargetString7 [Char]
s1 [Char]
s2 [Char]
s3 [Char]
s4 [Char]
s5 [Char]
s6 [Char]
s7
getFileStatus :: TargetStringFileStatus -> Maybe FileStatus
getFileStatus :: TargetStringFileStatus -> Maybe FileStatus
getFileStatus (TargetStringFileStatus1 [Char]
_ FileStatus
f) = FileStatus -> Maybe FileStatus
forall a. a -> Maybe a
Just FileStatus
f
getFileStatus (TargetStringFileStatus2 [Char]
_ FileStatus
f [Char]
_) = FileStatus -> Maybe FileStatus
forall a. a -> Maybe a
Just FileStatus
f
getFileStatus (TargetStringFileStatus3 [Char]
_ FileStatus
f [Char]
_ [Char]
_) = FileStatus -> Maybe FileStatus
forall a. a -> Maybe a
Just FileStatus
f
getFileStatus TargetStringFileStatus
_ = Maybe FileStatus
forall a. Maybe a
Nothing
setFileStatus :: FileStatus -> TargetStringFileStatus -> TargetStringFileStatus
setFileStatus :: FileStatus -> TargetStringFileStatus -> TargetStringFileStatus
setFileStatus FileStatus
f (TargetStringFileStatus1 [Char]
s1 FileStatus
_) = [Char] -> FileStatus -> TargetStringFileStatus
TargetStringFileStatus1 [Char]
s1 FileStatus
f
setFileStatus FileStatus
f (TargetStringFileStatus2 [Char]
s1 FileStatus
_ [Char]
s2) = [Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 [Char]
s1 FileStatus
f [Char]
s2
setFileStatus FileStatus
f (TargetStringFileStatus3 [Char]
s1 FileStatus
_ [Char]
s2 [Char]
s3) = [Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 [Char]
s1 FileStatus
f [Char]
s2 [Char]
s3
setFileStatus FileStatus
_ TargetStringFileStatus
t = TargetStringFileStatus
t
copyFileStatus :: TargetStringFileStatus -> TargetStringFileStatus -> TargetStringFileStatus
copyFileStatus :: TargetStringFileStatus
-> TargetStringFileStatus -> TargetStringFileStatus
copyFileStatus TargetStringFileStatus
src TargetStringFileStatus
dst =
case TargetStringFileStatus -> Maybe FileStatus
getFileStatus TargetStringFileStatus
src of
Just FileStatus
f -> FileStatus -> TargetStringFileStatus -> TargetStringFileStatus
setFileStatus FileStatus
f TargetStringFileStatus
dst
Maybe FileStatus
Nothing -> TargetStringFileStatus
dst
resolveTargetSelectors
:: KnownTargets
-> [TargetStringFileStatus]
-> Maybe ComponentKindFilter
-> ( [TargetSelectorProblem]
, [TargetSelector]
)
resolveTargetSelectors :: KnownTargets
-> [TargetStringFileStatus]
-> Maybe ComponentKind
-> ([TargetSelectorProblem], [TargetSelector])
resolveTargetSelectors (KnownTargets{knownPackagesAll :: KnownTargets -> [KnownPackage]
knownPackagesAll = []}) [] Maybe ComponentKind
_ =
([TargetSelectorProblem
TargetSelectorNoTargetsInProject], [])
resolveTargetSelectors (KnownTargets{knownPackagesPrimary :: KnownTargets -> [KnownPackage]
knownPackagesPrimary = []}) [] Maybe ComponentKind
ckf =
([Bool -> TargetSelectorProblem
TargetSelectorNoTargetsInCwd (Maybe ComponentKind
ckf Maybe ComponentKind -> Maybe ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
/= ComponentKind -> Maybe ComponentKind
forall a. a -> Maybe a
Just ComponentKind
ExeKind)], [])
resolveTargetSelectors (KnownTargets{[KnownPackage]
knownPackagesPrimary :: KnownTargets -> [KnownPackage]
knownPackagesPrimary :: [KnownPackage]
knownPackagesPrimary}) [] Maybe ComponentKind
_ =
([], [TargetImplicitCwd
-> [PackageIdentifier] -> Maybe ComponentKind -> TargetSelector
TargetPackage TargetImplicitCwd
TargetImplicitCwd [PackageIdentifier]
pkgids Maybe ComponentKind
forall a. Maybe a
Nothing])
where
pkgids :: [PackageIdentifier]
pkgids = [PackageIdentifier
pinfoId | KnownPackage{PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId} <- [KnownPackage]
knownPackagesPrimary]
resolveTargetSelectors KnownTargets
knowntargets [TargetStringFileStatus]
targetStrs Maybe ComponentKind
mfilter =
[Either TargetSelectorProblem TargetSelector]
-> ([TargetSelectorProblem], [TargetSelector])
forall a b. [Either a b] -> ([a], [b])
partitionEithers
([Either TargetSelectorProblem TargetSelector]
-> ([TargetSelectorProblem], [TargetSelector]))
-> ([TargetStringFileStatus]
-> [Either TargetSelectorProblem TargetSelector])
-> [TargetStringFileStatus]
-> ([TargetSelectorProblem], [TargetSelector])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TargetStringFileStatus
-> Either TargetSelectorProblem TargetSelector)
-> [TargetStringFileStatus]
-> [Either TargetSelectorProblem TargetSelector]
forall a b. (a -> b) -> [a] -> [b]
map (KnownTargets
-> Maybe ComponentKind
-> TargetStringFileStatus
-> Either TargetSelectorProblem TargetSelector
resolveTargetSelector KnownTargets
knowntargets Maybe ComponentKind
mfilter)
([TargetStringFileStatus]
-> ([TargetSelectorProblem], [TargetSelector]))
-> [TargetStringFileStatus]
-> ([TargetSelectorProblem], [TargetSelector])
forall a b. (a -> b) -> a -> b
$ [TargetStringFileStatus]
targetStrs
resolveTargetSelector
:: KnownTargets
-> Maybe ComponentKindFilter
-> TargetStringFileStatus
-> Either TargetSelectorProblem TargetSelector
resolveTargetSelector :: KnownTargets
-> Maybe ComponentKind
-> TargetStringFileStatus
-> Either TargetSelectorProblem TargetSelector
resolveTargetSelector knowntargets :: KnownTargets
knowntargets@KnownTargets{[KnownComponent]
[KnownPackage]
knownPackagesAll :: KnownTargets -> [KnownPackage]
knownPackagesPrimary :: KnownTargets -> [KnownPackage]
knownPackagesAll :: [KnownPackage]
knownPackagesPrimary :: [KnownPackage]
knownPackagesOther :: [KnownPackage]
knownComponentsAll :: [KnownComponent]
knownComponentsPrimary :: [KnownComponent]
knownComponentsOther :: [KnownComponent]
knownPackagesOther :: KnownTargets -> [KnownPackage]
knownComponentsAll :: KnownTargets -> [KnownComponent]
knownComponentsPrimary :: KnownTargets -> [KnownComponent]
knownComponentsOther :: KnownTargets -> [KnownComponent]
..} Maybe ComponentKind
mfilter TargetStringFileStatus
targetStrStatus =
case Match TargetSelector -> MaybeAmbiguous TargetSelector
forall a. Match a -> MaybeAmbiguous a
findMatch (TargetStringFileStatus -> Match TargetSelector
matcher TargetStringFileStatus
targetStrStatus) of
Unambiguous TargetSelector
_
| Bool
projectIsEmpty -> TargetSelectorProblem
-> Either TargetSelectorProblem TargetSelector
forall a b. a -> Either a b
Left TargetSelectorProblem
TargetSelectorNoTargetsInProject
Unambiguous (TargetPackage TargetImplicitCwd
TargetImplicitCwd [] Maybe ComponentKind
_) ->
TargetSelectorProblem
-> Either TargetSelectorProblem TargetSelector
forall a b. a -> Either a b
Left (TargetString -> TargetSelectorProblem
TargetSelectorNoCurrentPackage TargetString
targetStr)
Unambiguous TargetSelector
target -> TargetSelector -> Either TargetSelectorProblem TargetSelector
forall a b. b -> Either a b
Right TargetSelector
target
None [MatchError]
errs
| Bool
projectIsEmpty -> TargetSelectorProblem
-> Either TargetSelectorProblem TargetSelector
forall a b. a -> Either a b
Left TargetSelectorProblem
TargetSelectorNoTargetsInProject
| Bool
otherwise -> TargetSelectorProblem
-> Either TargetSelectorProblem TargetSelector
forall a b. a -> Either a b
Left ([MatchError] -> TargetSelectorProblem
classifyMatchErrors [MatchError]
errs)
Ambiguous MatchClass
_ [TargetSelector]
targets
| Just ComponentKind
kfilter <- Maybe ComponentKind
mfilter
, [TargetSelector
target] <- ComponentKind -> [TargetSelector] -> [TargetSelector]
applyKindFilter ComponentKind
kfilter [TargetSelector]
targets ->
TargetSelector -> Either TargetSelectorProblem TargetSelector
forall a b. b -> Either a b
Right TargetSelector
target
Ambiguous MatchClass
exactMatch [TargetSelector]
targets ->
case (TargetStringFileStatus -> Match TargetSelector)
-> TargetStringFileStatus
-> MatchClass
-> [TargetSelector]
-> Either
[(TargetSelector, [(TargetString, [TargetSelector])])]
[(TargetString, TargetSelector)]
disambiguateTargetSelectors
TargetStringFileStatus -> Match TargetSelector
matcher
TargetStringFileStatus
targetStrStatus
MatchClass
exactMatch
[TargetSelector]
targets of
Right [(TargetString, TargetSelector)]
targets' -> TargetSelectorProblem
-> Either TargetSelectorProblem TargetSelector
forall a b. a -> Either a b
Left (TargetString
-> [(TargetString, TargetSelector)] -> TargetSelectorProblem
TargetSelectorAmbiguous TargetString
targetStr [(TargetString, TargetSelector)]
targets')
Left ((TargetSelector
m, [(TargetString, [TargetSelector])]
ms) : [(TargetSelector, [(TargetString, [TargetSelector])])]
_) -> TargetSelectorProblem
-> Either TargetSelectorProblem TargetSelector
forall a b. a -> Either a b
Left (TargetString
-> TargetSelector
-> [(TargetString, [TargetSelector])]
-> TargetSelectorProblem
MatchingInternalError TargetString
targetStr TargetSelector
m [(TargetString, [TargetSelector])]
ms)
Left [] -> [Char] -> Either TargetSelectorProblem TargetSelector
forall a. [Char] -> a
internalError [Char]
"resolveTargetSelector"
where
matcher :: TargetStringFileStatus -> Match TargetSelector
matcher = KnownTargets -> TargetStringFileStatus -> Match TargetSelector
matchTargetSelector KnownTargets
knowntargets
targetStr :: TargetString
targetStr = TargetStringFileStatus -> TargetString
forgetFileStatus TargetStringFileStatus
targetStrStatus
projectIsEmpty :: Bool
projectIsEmpty = [KnownPackage] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [KnownPackage]
knownPackagesAll
classifyMatchErrors :: [MatchError] -> TargetSelectorProblem
classifyMatchErrors [MatchError]
errs
| Just NonEmpty ([Char], [Char])
expectedNE <- [([Char], [Char])] -> Maybe (NonEmpty ([Char], [Char]))
forall a. [a] -> Maybe (NonEmpty a)
NE.nonEmpty [([Char], [Char])]
expected =
let (NonEmpty [Char]
things, [Char]
got :| [[Char]]
_) = NonEmpty ([Char], [Char]) -> (NonEmpty [Char], NonEmpty [Char])
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
UZ.unzip NonEmpty ([Char], [Char])
expectedNE
in TargetString -> [[Char]] -> [Char] -> TargetSelectorProblem
TargetSelectorExpected TargetString
targetStr (NonEmpty [Char] -> [[Char]]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty [Char]
things) [Char]
got
| Bool -> Bool
not ([(Maybe ([Char], [Char]), [Char], [Char], [[Char]])] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
nosuch) =
TargetString
-> [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
-> TargetSelectorProblem
TargetSelectorNoSuch TargetString
targetStr [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
nosuch
| Bool
otherwise =
[Char] -> TargetSelectorProblem
forall a. [Char] -> a
internalError ([Char] -> TargetSelectorProblem)
-> [Char] -> TargetSelectorProblem
forall a b. (a -> b) -> a -> b
$ [Char]
"classifyMatchErrors: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [MatchError] -> [Char]
forall a. Show a => a -> [Char]
show [MatchError]
errs
where
expected :: [([Char], [Char])]
expected =
[ ([Char]
thing, [Char]
got)
| (Maybe ([Char], [Char])
_, MatchErrorExpected [Char]
thing [Char]
got) <-
(MatchError -> (Maybe ([Char], [Char]), MatchError))
-> [MatchError] -> [(Maybe ([Char], [Char]), MatchError)]
forall a b. (a -> b) -> [a] -> [b]
map (Maybe ([Char], [Char])
-> MatchError -> (Maybe ([Char], [Char]), MatchError)
innerErr Maybe ([Char], [Char])
forall a. Maybe a
Nothing) [MatchError]
errs
]
nosuch :: [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
nosuch =
((Maybe ([Char], [Char]), [Char], [Char])
-> Set [Char]
-> [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
-> [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])
-> [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
-> Map (Maybe ([Char], [Char]), [Char], [Char]) (Set [Char])
-> [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
Map.foldrWithKey (Maybe ([Char], [Char]), [Char], [Char])
-> Set [Char]
-> [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
-> [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
forall {a} {b}.
(a, b, [Char])
-> Set [Char]
-> [(a, b, [Char], [[Char]])]
-> [(a, b, [Char], [[Char]])]
genResults [] (Map (Maybe ([Char], [Char]), [Char], [Char]) (Set [Char])
-> [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])
-> Map (Maybe ([Char], [Char]), [Char], [Char]) (Set [Char])
-> [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
forall a b. (a -> b) -> a -> b
$
(Set [Char] -> Set [Char] -> Set [Char])
-> [((Maybe ([Char], [Char]), [Char], [Char]), Set [Char])]
-> Map (Maybe ([Char], [Char]), [Char], [Char]) (Set [Char])
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.union ([((Maybe ([Char], [Char]), [Char], [Char]), Set [Char])]
-> Map (Maybe ([Char], [Char]), [Char], [Char]) (Set [Char]))
-> [((Maybe ([Char], [Char]), [Char], [Char]), Set [Char])]
-> Map (Maybe ([Char], [Char]), [Char], [Char]) (Set [Char])
forall a b. (a -> b) -> a -> b
$
[ ((Maybe ([Char], [Char])
inside, [Char]
thing, [Char]
got), [[Char]] -> Set [Char]
forall a. Ord a => [a] -> Set a
Set.fromList [[Char]]
alts)
| (Maybe ([Char], [Char])
inside, MatchErrorNoSuch [Char]
thing [Char]
got [[Char]]
alts) <-
(MatchError -> (Maybe ([Char], [Char]), MatchError))
-> [MatchError] -> [(Maybe ([Char], [Char]), MatchError)]
forall a b. (a -> b) -> [a] -> [b]
map (Maybe ([Char], [Char])
-> MatchError -> (Maybe ([Char], [Char]), MatchError)
innerErr Maybe ([Char], [Char])
forall a. Maybe a
Nothing) [MatchError]
errs
]
genResults :: (a, b, [Char])
-> Set [Char]
-> [(a, b, [Char], [[Char]])]
-> [(a, b, [Char], [[Char]])]
genResults (a
inside, b
thing, [Char]
got) Set [Char]
alts [(a, b, [Char], [[Char]])]
acc =
( a
inside
, b
thing
, [Char]
got
, Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
take Int
maxResults ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$
(([Char], Int) -> [Char]) -> [([Char], Int)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], Int) -> [Char]
forall a b. (a, b) -> a
fst ([([Char], Int)] -> [[Char]]) -> [([Char], Int)] -> [[Char]]
forall a b. (a -> b) -> a -> b
$
(([Char], Int) -> Bool) -> [([Char], Int)] -> [([Char], Int)]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile ([Char], Int) -> Bool
forall {a}. (a, Int) -> Bool
distanceLow ([([Char], Int)] -> [([Char], Int)])
-> [([Char], Int)] -> [([Char], Int)]
forall a b. (a -> b) -> a -> b
$
(([Char], Int) -> ([Char], Int) -> Ordering)
-> [([Char], Int)] -> [([Char], Int)]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy ((([Char], Int) -> Int)
-> ([Char], Int) -> ([Char], Int) -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing ([Char], Int) -> Int
forall a b. (a, b) -> b
snd) ([([Char], Int)] -> [([Char], Int)])
-> [([Char], Int)] -> [([Char], Int)]
forall a b. (a -> b) -> a -> b
$
([Char] -> ([Char], Int)) -> [[Char]] -> [([Char], Int)]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> ([Char], Int)
addLevDist ([[Char]] -> [([Char], Int)]) -> [[Char]] -> [([Char], Int)]
forall a b. (a -> b) -> a -> b
$
Set [Char] -> [[Char]]
forall a. Set a -> [a]
Set.toList Set [Char]
alts
)
(a, b, [Char], [[Char]])
-> [(a, b, [Char], [[Char]])] -> [(a, b, [Char], [[Char]])]
forall a. a -> [a] -> [a]
: [(a, b, [Char], [[Char]])]
acc
where
addLevDist :: [Char] -> ([Char], Int)
addLevDist =
ShowS
forall a. a -> a
id
ShowS -> ([Char] -> Int) -> [Char] -> ([Char], Int)
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& EditCosts -> [Char] -> [Char] -> Int
restrictedDamerauLevenshteinDistance
EditCosts
defaultEditCosts
[Char]
got
distanceLow :: (a, Int) -> Bool
distanceLow (a
_, Int
dist) = Int
dist Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< [Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
got Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2
maxResults :: Int
maxResults = Int
3
innerErr :: Maybe ([Char], [Char])
-> MatchError -> (Maybe ([Char], [Char]), MatchError)
innerErr Maybe ([Char], [Char])
_ (MatchErrorIn [Char]
kind [Char]
thing MatchError
m) =
Maybe ([Char], [Char])
-> MatchError -> (Maybe ([Char], [Char]), MatchError)
innerErr (([Char], [Char]) -> Maybe ([Char], [Char])
forall a. a -> Maybe a
Just ([Char]
kind, [Char]
thing)) MatchError
m
innerErr Maybe ([Char], [Char])
c MatchError
m = (Maybe ([Char], [Char])
c, MatchError
m)
applyKindFilter :: ComponentKindFilter -> [TargetSelector] -> [TargetSelector]
applyKindFilter :: ComponentKind -> [TargetSelector] -> [TargetSelector]
applyKindFilter ComponentKind
kfilter = (TargetSelector -> Bool) -> [TargetSelector] -> [TargetSelector]
forall a. (a -> Bool) -> [a] -> [a]
filter TargetSelector -> Bool
go
where
go :: TargetSelector -> Bool
go (TargetPackage TargetImplicitCwd
_ [PackageIdentifier]
_ (Just ComponentKind
filter')) = ComponentKind
kfilter ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentKind
filter'
go (TargetPackageNamed PackageName
_ (Just ComponentKind
filter')) = ComponentKind
kfilter ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentKind
filter'
go (TargetAllPackages (Just ComponentKind
filter')) = ComponentKind
kfilter ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentKind
filter'
go (TargetComponent PackageIdentifier
_ ComponentName
cname SubComponentTarget
_)
| CLibName LibraryName
_ <- ComponentName
cname = ComponentKind
kfilter ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentKind
LibKind
| CFLibName UnqualComponentName
_ <- ComponentName
cname = ComponentKind
kfilter ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentKind
FLibKind
| CExeName UnqualComponentName
_ <- ComponentName
cname = ComponentKind
kfilter ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentKind
ExeKind
| CTestName UnqualComponentName
_ <- ComponentName
cname = ComponentKind
kfilter ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentKind
TestKind
| CBenchName UnqualComponentName
_ <- ComponentName
cname = ComponentKind
kfilter ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
== ComponentKind
BenchKind
go TargetSelector
_ = Bool
True
data TargetSelectorProblem
=
TargetSelectorExpected TargetString [String] String
|
TargetSelectorNoSuch
TargetString
[(Maybe (String, String), String, String, [String])]
| TargetSelectorAmbiguous
TargetString
[(TargetString, TargetSelector)]
| MatchingInternalError
TargetString
TargetSelector
[(TargetString, [TargetSelector])]
|
TargetSelectorUnrecognised String
| TargetSelectorNoCurrentPackage TargetString
|
TargetSelectorNoTargetsInCwd Bool
| TargetSelectorNoTargetsInProject
| TargetSelectorNoScript TargetString
deriving (Int -> TargetSelectorProblem -> ShowS
[TargetSelectorProblem] -> ShowS
TargetSelectorProblem -> [Char]
(Int -> TargetSelectorProblem -> ShowS)
-> (TargetSelectorProblem -> [Char])
-> ([TargetSelectorProblem] -> ShowS)
-> Show TargetSelectorProblem
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TargetSelectorProblem -> ShowS
showsPrec :: Int -> TargetSelectorProblem -> ShowS
$cshow :: TargetSelectorProblem -> [Char]
show :: TargetSelectorProblem -> [Char]
$cshowList :: [TargetSelectorProblem] -> ShowS
showList :: [TargetSelectorProblem] -> ShowS
Show, TargetSelectorProblem -> TargetSelectorProblem -> Bool
(TargetSelectorProblem -> TargetSelectorProblem -> Bool)
-> (TargetSelectorProblem -> TargetSelectorProblem -> Bool)
-> Eq TargetSelectorProblem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TargetSelectorProblem -> TargetSelectorProblem -> Bool
== :: TargetSelectorProblem -> TargetSelectorProblem -> Bool
$c/= :: TargetSelectorProblem -> TargetSelectorProblem -> Bool
/= :: TargetSelectorProblem -> TargetSelectorProblem -> Bool
Eq)
data QualLevel
=
QL1
|
QL2
|
QL3
|
QLFull
deriving (QualLevel -> QualLevel -> Bool
(QualLevel -> QualLevel -> Bool)
-> (QualLevel -> QualLevel -> Bool) -> Eq QualLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualLevel -> QualLevel -> Bool
== :: QualLevel -> QualLevel -> Bool
$c/= :: QualLevel -> QualLevel -> Bool
/= :: QualLevel -> QualLevel -> Bool
Eq, Int -> QualLevel
QualLevel -> Int
QualLevel -> [QualLevel]
QualLevel -> QualLevel
QualLevel -> QualLevel -> [QualLevel]
QualLevel -> QualLevel -> QualLevel -> [QualLevel]
(QualLevel -> QualLevel)
-> (QualLevel -> QualLevel)
-> (Int -> QualLevel)
-> (QualLevel -> Int)
-> (QualLevel -> [QualLevel])
-> (QualLevel -> QualLevel -> [QualLevel])
-> (QualLevel -> QualLevel -> [QualLevel])
-> (QualLevel -> QualLevel -> QualLevel -> [QualLevel])
-> Enum QualLevel
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: QualLevel -> QualLevel
succ :: QualLevel -> QualLevel
$cpred :: QualLevel -> QualLevel
pred :: QualLevel -> QualLevel
$ctoEnum :: Int -> QualLevel
toEnum :: Int -> QualLevel
$cfromEnum :: QualLevel -> Int
fromEnum :: QualLevel -> Int
$cenumFrom :: QualLevel -> [QualLevel]
enumFrom :: QualLevel -> [QualLevel]
$cenumFromThen :: QualLevel -> QualLevel -> [QualLevel]
enumFromThen :: QualLevel -> QualLevel -> [QualLevel]
$cenumFromTo :: QualLevel -> QualLevel -> [QualLevel]
enumFromTo :: QualLevel -> QualLevel -> [QualLevel]
$cenumFromThenTo :: QualLevel -> QualLevel -> QualLevel -> [QualLevel]
enumFromThenTo :: QualLevel -> QualLevel -> QualLevel -> [QualLevel]
Enum, Int -> QualLevel -> ShowS
[QualLevel] -> ShowS
QualLevel -> [Char]
(Int -> QualLevel -> ShowS)
-> (QualLevel -> [Char])
-> ([QualLevel] -> ShowS)
-> Show QualLevel
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QualLevel -> ShowS
showsPrec :: Int -> QualLevel -> ShowS
$cshow :: QualLevel -> [Char]
show :: QualLevel -> [Char]
$cshowList :: [QualLevel] -> ShowS
showList :: [QualLevel] -> ShowS
Show)
disambiguateTargetSelectors
:: (TargetStringFileStatus -> Match TargetSelector)
-> TargetStringFileStatus
-> MatchClass
-> [TargetSelector]
-> Either
[(TargetSelector, [(TargetString, [TargetSelector])])]
[(TargetString, TargetSelector)]
disambiguateTargetSelectors :: (TargetStringFileStatus -> Match TargetSelector)
-> TargetStringFileStatus
-> MatchClass
-> [TargetSelector]
-> Either
[(TargetSelector, [(TargetString, [TargetSelector])])]
[(TargetString, TargetSelector)]
disambiguateTargetSelectors TargetStringFileStatus -> Match TargetSelector
matcher TargetStringFileStatus
matchInput MatchClass
exactMatch [TargetSelector]
matchResults =
case [Either
(TargetSelector, [(TargetString, [TargetSelector])])
(TargetString, TargetSelector)]
-> ([(TargetSelector, [(TargetString, [TargetSelector])])],
[(TargetString, TargetSelector)])
forall a b. [Either a b] -> ([a], [b])
partitionEithers [Either
(TargetSelector, [(TargetString, [TargetSelector])])
(TargetString, TargetSelector)]
results of
(errs :: [(TargetSelector, [(TargetString, [TargetSelector])])]
errs@((TargetSelector, [(TargetString, [TargetSelector])])
_ : [(TargetSelector, [(TargetString, [TargetSelector])])]
_), [(TargetString, TargetSelector)]
_) -> [(TargetSelector, [(TargetString, [TargetSelector])])]
-> Either
[(TargetSelector, [(TargetString, [TargetSelector])])]
[(TargetString, TargetSelector)]
forall a b. a -> Either a b
Left [(TargetSelector, [(TargetString, [TargetSelector])])]
errs
([], [(TargetString, TargetSelector)]
ok) -> [(TargetString, TargetSelector)]
-> Either
[(TargetSelector, [(TargetString, [TargetSelector])])]
[(TargetString, TargetSelector)]
forall a b. b -> Either a b
Right [(TargetString, TargetSelector)]
ok
where
matchResultsRenderings :: [(TargetSelector, [TargetStringFileStatus])]
matchResultsRenderings :: [(TargetSelector, [TargetStringFileStatus])]
matchResultsRenderings =
[ (TargetSelector
matchResult, [TargetStringFileStatus]
matchRenderings)
| TargetSelector
matchResult <- [TargetSelector]
matchResults
, let matchRenderings :: [TargetStringFileStatus]
matchRenderings =
[ TargetStringFileStatus
-> TargetStringFileStatus -> TargetStringFileStatus
copyFileStatus TargetStringFileStatus
matchInput TargetStringFileStatus
rendering
| QualLevel
ql <- [QualLevel
QL1 .. QualLevel
QLFull]
, TargetStringFileStatus
rendering <- QualLevel -> TargetSelector -> [TargetStringFileStatus]
renderTargetSelector QualLevel
ql TargetSelector
matchResult
]
]
memoisedMatches :: Map TargetStringFileStatus (Match TargetSelector)
memoisedMatches :: Map TargetStringFileStatus (Match TargetSelector)
memoisedMatches =
( if MatchClass
exactMatch MatchClass -> MatchClass -> Bool
forall a. Eq a => a -> a -> Bool
== MatchClass
Exact
then TargetStringFileStatus
-> Match TargetSelector
-> Map TargetStringFileStatus (Match TargetSelector)
-> Map TargetStringFileStatus (Match TargetSelector)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert TargetStringFileStatus
matchInput (MatchClass -> Int -> [TargetSelector] -> Match TargetSelector
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
Exact Int
0 [TargetSelector]
matchResults)
else Map TargetStringFileStatus (Match TargetSelector)
-> Map TargetStringFileStatus (Match TargetSelector)
forall a. a -> a
id
)
(Map TargetStringFileStatus (Match TargetSelector)
-> Map TargetStringFileStatus (Match TargetSelector))
-> Map TargetStringFileStatus (Match TargetSelector)
-> Map TargetStringFileStatus (Match TargetSelector)
forall a b. (a -> b) -> a -> b
$ [(TargetStringFileStatus, Match TargetSelector)]
-> Map TargetStringFileStatus (Match TargetSelector)
forall k a. Ord k => [(k, a)] -> Map k a
Map.Lazy.fromList
[ (TargetStringFileStatus
rendering, TargetStringFileStatus -> Match TargetSelector
matcher TargetStringFileStatus
rendering)
| TargetStringFileStatus
rendering <- ((TargetSelector, [TargetStringFileStatus])
-> [TargetStringFileStatus])
-> [(TargetSelector, [TargetStringFileStatus])]
-> [TargetStringFileStatus]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (TargetSelector, [TargetStringFileStatus])
-> [TargetStringFileStatus]
forall a b. (a, b) -> b
snd [(TargetSelector, [TargetStringFileStatus])]
matchResultsRenderings
]
results
:: [ Either
(TargetSelector, [(TargetString, [TargetSelector])])
(TargetString, TargetSelector)
]
results :: [Either
(TargetSelector, [(TargetString, [TargetSelector])])
(TargetString, TargetSelector)]
results =
[ case TargetSelector
-> [TargetStringFileStatus] -> Maybe TargetStringFileStatus
findUnambiguous TargetSelector
originalMatch [TargetStringFileStatus]
matchRenderings of
Just TargetStringFileStatus
unambiguousRendering ->
(TargetString, TargetSelector)
-> Either
(TargetSelector, [(TargetString, [TargetSelector])])
(TargetString, TargetSelector)
forall a b. b -> Either a b
Right
( TargetStringFileStatus -> TargetString
forgetFileStatus TargetStringFileStatus
unambiguousRendering
, TargetSelector
originalMatch
)
Maybe TargetStringFileStatus
Nothing ->
(TargetSelector, [(TargetString, [TargetSelector])])
-> Either
(TargetSelector, [(TargetString, [TargetSelector])])
(TargetString, TargetSelector)
forall a b. a -> Either a b
Left
( TargetSelector
originalMatch
, [ (TargetStringFileStatus -> TargetString
forgetFileStatus TargetStringFileStatus
rendering, [TargetSelector]
matches)
| TargetStringFileStatus
rendering <- [TargetStringFileStatus]
matchRenderings
, let Match MatchClass
m Int
_ [TargetSelector]
matches =
Map TargetStringFileStatus (Match TargetSelector)
memoisedMatches Map TargetStringFileStatus (Match TargetSelector)
-> TargetStringFileStatus -> Match TargetSelector
forall k a. Ord k => Map k a -> k -> a
Map.! TargetStringFileStatus
rendering
, MatchClass
m MatchClass -> MatchClass -> Bool
forall a. Eq a => a -> a -> Bool
/= MatchClass
Inexact
]
)
| (TargetSelector
originalMatch, [TargetStringFileStatus]
matchRenderings) <- [(TargetSelector, [TargetStringFileStatus])]
matchResultsRenderings
]
findUnambiguous
:: TargetSelector
-> [TargetStringFileStatus]
-> Maybe TargetStringFileStatus
findUnambiguous :: TargetSelector
-> [TargetStringFileStatus] -> Maybe TargetStringFileStatus
findUnambiguous TargetSelector
_ [] = Maybe TargetStringFileStatus
forall a. Maybe a
Nothing
findUnambiguous TargetSelector
t (TargetStringFileStatus
r : [TargetStringFileStatus]
rs) =
case Map TargetStringFileStatus (Match TargetSelector)
memoisedMatches Map TargetStringFileStatus (Match TargetSelector)
-> TargetStringFileStatus -> Match TargetSelector
forall k a. Ord k => Map k a -> k -> a
Map.! TargetStringFileStatus
r of
Match MatchClass
Exact Int
_ [TargetSelector
t']
| TargetSelector
t TargetSelector -> TargetSelector -> Bool
forall a. Eq a => a -> a -> Bool
== TargetSelector
t' ->
TargetStringFileStatus -> Maybe TargetStringFileStatus
forall a. a -> Maybe a
Just TargetStringFileStatus
r
Match MatchClass
Exact Int
_ [TargetSelector]
_ -> TargetSelector
-> [TargetStringFileStatus] -> Maybe TargetStringFileStatus
findUnambiguous TargetSelector
t [TargetStringFileStatus]
rs
Match MatchClass
Unknown Int
_ [TargetSelector]
_ -> TargetSelector
-> [TargetStringFileStatus] -> Maybe TargetStringFileStatus
findUnambiguous TargetSelector
t [TargetStringFileStatus]
rs
Match MatchClass
Inexact Int
_ [TargetSelector]
_ -> [Char] -> Maybe TargetStringFileStatus
forall a. [Char] -> a
internalError [Char]
"Match Inexact"
NoMatch Int
_ [MatchError]
_ -> [Char] -> Maybe TargetStringFileStatus
forall a. [Char] -> a
internalError [Char]
"NoMatch"
internalError :: String -> a
internalError :: forall a. [Char] -> a
internalError [Char]
msg =
[Char] -> a
forall a. HasCallStack => [Char] -> a
error ([Char] -> a) -> [Char] -> a
forall a b. (a -> b) -> a -> b
$ [Char]
"TargetSelector: internal error: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
msg
reportTargetSelectorProblems :: Verbosity -> [TargetSelectorProblem] -> IO a
reportTargetSelectorProblems :: forall a. Verbosity -> [TargetSelectorProblem] -> IO a
reportTargetSelectorProblems Verbosity
verbosity [TargetSelectorProblem]
problems = do
case [[Char]
str | TargetSelectorUnrecognised [Char]
str <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
[[Char]]
targets -> Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$ [[Char]] -> CabalInstallException
ReportTargetSelectorProblems [[Char]]
targets
case [(TargetString
t, TargetSelector
m, [(TargetString, [TargetSelector])]
ms) | MatchingInternalError TargetString
t TargetSelector
m [(TargetString, [TargetSelector])]
ms <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
((TargetString
target, TargetSelector
originalMatch, [(TargetString, [TargetSelector])]
renderingsAndMatches) : [(TargetString, TargetSelector,
[(TargetString, [TargetSelector])])]
_) ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity
(CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
-> [Char]
-> [Char]
-> [([Char], [[Char]])]
-> CabalInstallException
MatchingInternalErrorErr
(TargetString -> [Char]
showTargetString TargetString
target)
(TargetSelector -> [Char]
showTargetSelector TargetSelector
originalMatch)
(TargetSelector -> [Char]
showTargetSelectorKind TargetSelector
originalMatch)
([([Char], [[Char]])] -> CabalInstallException)
-> [([Char], [[Char]])] -> CabalInstallException
forall a b. (a -> b) -> a -> b
$ ((TargetString, [TargetSelector]) -> ([Char], [[Char]]))
-> [(TargetString, [TargetSelector])] -> [([Char], [[Char]])]
forall a b. (a -> b) -> [a] -> [b]
map
( \(TargetString
rendering, [TargetSelector]
matches) ->
( TargetString -> [Char]
showTargetString TargetString
rendering
, ((TargetSelector -> [Char]) -> [TargetSelector] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (\TargetSelector
match -> TargetSelector -> [Char]
showTargetSelector TargetSelector
match [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" (" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ TargetSelector -> [Char]
showTargetSelectorKind TargetSelector
match [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")") [TargetSelector]
matches)
)
)
[(TargetString, [TargetSelector])]
renderingsAndMatches
case [(TargetString
t, [[Char]]
e, [Char]
g) | TargetSelectorExpected TargetString
t [[Char]]
e [Char]
g <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
[(TargetString, [[Char]], [Char])]
targets ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$
[([Char], [[Char]], [Char])] -> CabalInstallException
UnrecognisedTarget ([([Char], [[Char]], [Char])] -> CabalInstallException)
-> [([Char], [[Char]], [Char])] -> CabalInstallException
forall a b. (a -> b) -> a -> b
$
((TargetString, [[Char]], [Char]) -> ([Char], [[Char]], [Char]))
-> [(TargetString, [[Char]], [Char])]
-> [([Char], [[Char]], [Char])]
forall a b. (a -> b) -> [a] -> [b]
map (\(TargetString
target, [[Char]]
expected, [Char]
got) -> (TargetString -> [Char]
showTargetString TargetString
target, [[Char]]
expected, [Char]
got)) [(TargetString, [[Char]], [Char])]
targets
case [(TargetString
t, [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
e) | TargetSelectorNoSuch TargetString
t [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
e <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
[(TargetString,
[(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])]
targets ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$
[([Char], [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])]
-> CabalInstallException
NoSuchTargetSelectorErr ([([Char], [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])]
-> CabalInstallException)
-> [([Char], [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])]
-> CabalInstallException
forall a b. (a -> b) -> a -> b
$
((TargetString,
[(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])
-> ([Char], [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]))
-> [(TargetString,
[(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])]
-> [([Char], [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])]
forall a b. (a -> b) -> [a] -> [b]
map (\(TargetString
target, [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
nosuch) -> (TargetString -> [Char]
showTargetString TargetString
target, [(Maybe ([Char], [Char]), [Char], [Char], [[Char]])]
nosuch)) [(TargetString,
[(Maybe ([Char], [Char]), [Char], [Char], [[Char]])])]
targets
case [(TargetString
t, [(TargetString, TargetSelector)]
ts) | TargetSelectorAmbiguous TargetString
t [(TargetString, TargetSelector)]
ts <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
[(TargetString, [(TargetString, TargetSelector)])]
targets ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$
[([Char], [([Char], [Char])])] -> CabalInstallException
TargetSelectorAmbiguousErr ([([Char], [([Char], [Char])])] -> CabalInstallException)
-> [([Char], [([Char], [Char])])] -> CabalInstallException
forall a b. (a -> b) -> a -> b
$
((TargetString, [(TargetString, TargetSelector)])
-> ([Char], [([Char], [Char])]))
-> [(TargetString, [(TargetString, TargetSelector)])]
-> [([Char], [([Char], [Char])])]
forall a b. (a -> b) -> [a] -> [b]
map
( \(TargetString
target, [(TargetString, TargetSelector)]
amb) ->
( TargetString -> [Char]
showTargetString TargetString
target
, (((TargetString, TargetSelector) -> ([Char], [Char]))
-> [(TargetString, TargetSelector)] -> [([Char], [Char])]
forall a b. (a -> b) -> [a] -> [b]
map (\(TargetString
ut, TargetSelector
bt) -> (TargetString -> [Char]
showTargetString TargetString
ut, TargetSelector -> [Char]
showTargetSelectorKind TargetSelector
bt)) [(TargetString, TargetSelector)]
amb)
)
)
[(TargetString, [(TargetString, TargetSelector)])]
targets
case [TargetString
t | TargetSelectorNoCurrentPackage TargetString
t <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
TargetString
target : [TargetString]
_ ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> CabalInstallException
TargetSelectorNoCurrentPackageErr (TargetString -> [Char]
showTargetString TargetString
target)
case [() | TargetSelectorNoTargetsInCwd Bool
True <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
()
_ : [()]
_ ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity CabalInstallException
TargetSelectorNoTargetsInCwdTrue
case [() | TargetSelectorNoTargetsInCwd Bool
False <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
()
_ : [()]
_ ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity CabalInstallException
TargetSelectorNoTargetsInCwdFalse
case [() | TargetSelectorProblem
TargetSelectorNoTargetsInProject <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
()
_ : [()]
_ ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity CabalInstallException
TargetSelectorNoTargetsInProjectErr
case [TargetString
t | TargetSelectorNoScript TargetString
t <- [TargetSelectorProblem]
problems] of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
TargetString
target : [TargetString]
_ ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> CabalInstallException
TargetSelectorNoScriptErr (TargetString -> [Char]
showTargetString TargetString
target)
[Char] -> IO a
forall a. HasCallStack => [Char] -> IO a
forall (m :: * -> *) a.
(MonadFail m, HasCallStack) =>
[Char] -> m a
fail [Char]
"reportTargetSelectorProblems: internal error"
data Syntax
= Syntax QualLevel Matcher Renderer
| AmbiguousAlternatives Syntax Syntax
| ShadowingAlternatives Syntax Syntax
type Matcher = TargetStringFileStatus -> Match TargetSelector
type Renderer = TargetSelector -> [TargetStringFileStatus]
foldSyntax
:: (a -> a -> a)
-> (a -> a -> a)
-> (QualLevel -> Matcher -> Renderer -> a)
-> (Syntax -> a)
foldSyntax :: forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> a)
-> Syntax
-> a
foldSyntax a -> a -> a
ambiguous a -> a -> a
unambiguous QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> a
syntax = Syntax -> a
go
where
go :: Syntax -> a
go (Syntax QualLevel
ql TargetStringFileStatus -> Match TargetSelector
match TargetSelector -> [TargetStringFileStatus]
render) = QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> a
syntax QualLevel
ql TargetStringFileStatus -> Match TargetSelector
match TargetSelector -> [TargetStringFileStatus]
render
go (AmbiguousAlternatives Syntax
a Syntax
b) = a -> a -> a
ambiguous (Syntax -> a
go Syntax
a) (Syntax -> a
go Syntax
b)
go (ShadowingAlternatives Syntax
a Syntax
b) = a -> a -> a
unambiguous (Syntax -> a
go Syntax
a) (Syntax -> a
go Syntax
b)
renderTargetSelector
:: QualLevel
-> TargetSelector
-> [TargetStringFileStatus]
renderTargetSelector :: QualLevel -> TargetSelector -> [TargetStringFileStatus]
renderTargetSelector QualLevel
ql TargetSelector
ts =
([TargetStringFileStatus]
-> [TargetStringFileStatus] -> [TargetStringFileStatus])
-> ([TargetStringFileStatus]
-> [TargetStringFileStatus] -> [TargetStringFileStatus])
-> (QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> [TargetStringFileStatus])
-> Syntax
-> [TargetStringFileStatus]
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> a)
-> Syntax
-> a
foldSyntax
[TargetStringFileStatus]
-> [TargetStringFileStatus] -> [TargetStringFileStatus]
forall a. [a] -> [a] -> [a]
(++)
[TargetStringFileStatus]
-> [TargetStringFileStatus] -> [TargetStringFileStatus]
forall a. [a] -> [a] -> [a]
(++)
(\QualLevel
ql' TargetStringFileStatus -> Match TargetSelector
_ TargetSelector -> [TargetStringFileStatus]
render -> Bool -> [()]
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (QualLevel
ql QualLevel -> QualLevel -> Bool
forall a. Eq a => a -> a -> Bool
== QualLevel
ql') [()] -> [TargetStringFileStatus] -> [TargetStringFileStatus]
forall a b. [a] -> [b] -> [b]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TargetSelector -> [TargetStringFileStatus]
render TargetSelector
ts)
Syntax
syntax
where
syntax :: Syntax
syntax = KnownTargets -> Syntax
syntaxForms KnownTargets
emptyKnownTargets
matchTargetSelector
:: KnownTargets
-> TargetStringFileStatus
-> Match TargetSelector
matchTargetSelector :: KnownTargets -> TargetStringFileStatus -> Match TargetSelector
matchTargetSelector KnownTargets
knowntargets = \TargetStringFileStatus
usertarget ->
(TargetSelector -> TargetSelector -> Bool)
-> Match TargetSelector -> Match TargetSelector
forall a. (a -> a -> Bool) -> Match a -> Match a
nubMatchesBy TargetSelector -> TargetSelector -> Bool
forall a. Eq a => a -> a -> Bool
(==) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$
let ql :: QualLevel
ql = TargetStringFileStatus -> QualLevel
targetQualLevel TargetStringFileStatus
usertarget
in (Match TargetSelector
-> Match TargetSelector -> Match TargetSelector)
-> (Match TargetSelector
-> Match TargetSelector -> Match TargetSelector)
-> (QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> Match TargetSelector)
-> Syntax
-> Match TargetSelector
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> a)
-> Syntax
-> a
foldSyntax
Match TargetSelector
-> Match TargetSelector -> Match TargetSelector
forall a. Match a -> Match a -> Match a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>)
Match TargetSelector
-> Match TargetSelector -> Match TargetSelector
forall a. Match a -> Match a -> Match a
(</>)
(\QualLevel
ql' TargetStringFileStatus -> Match TargetSelector
match TargetSelector -> [TargetStringFileStatus]
_ -> Bool -> Match ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (QualLevel
ql QualLevel -> QualLevel -> Bool
forall a. Eq a => a -> a -> Bool
== QualLevel
ql') Match () -> Match TargetSelector -> Match TargetSelector
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TargetStringFileStatus -> Match TargetSelector
match TargetStringFileStatus
usertarget)
Syntax
syntax
where
syntax :: Syntax
syntax = KnownTargets -> Syntax
syntaxForms KnownTargets
knowntargets
targetQualLevel :: TargetStringFileStatus -> QualLevel
targetQualLevel TargetStringFileStatus1{} = QualLevel
QL1
targetQualLevel TargetStringFileStatus2{} = QualLevel
QL2
targetQualLevel TargetStringFileStatus3{} = QualLevel
QL3
targetQualLevel TargetStringFileStatus4{} = QualLevel
QLFull
targetQualLevel TargetStringFileStatus5{} = QualLevel
QLFull
targetQualLevel TargetStringFileStatus7{} = QualLevel
QLFull
syntaxForms :: KnownTargets -> Syntax
syntaxForms :: KnownTargets -> Syntax
syntaxForms
KnownTargets
{ knownPackagesAll :: KnownTargets -> [KnownPackage]
knownPackagesAll = [KnownPackage]
pinfo
, knownPackagesPrimary :: KnownTargets -> [KnownPackage]
knownPackagesPrimary = [KnownPackage]
ppinfo
, knownComponentsAll :: KnownTargets -> [KnownComponent]
knownComponentsAll = [KnownComponent]
cinfo
, knownComponentsPrimary :: KnownTargets -> [KnownComponent]
knownComponentsPrimary = [KnownComponent]
pcinfo
, knownComponentsOther :: KnownTargets -> [KnownComponent]
knownComponentsOther = [KnownComponent]
ocinfo
} =
[Syntax] -> Syntax
ambiguousAlternatives
[ [Syntax] -> Syntax
shadowingAlternatives
[ [Syntax] -> Syntax
ambiguousAlternatives
[ Syntax
syntaxForm1All
, [KnownPackage] -> Syntax
syntaxForm1Filter [KnownPackage]
ppinfo
, [Syntax] -> Syntax
shadowingAlternatives
[ [KnownComponent] -> Syntax
syntaxForm1Component [KnownComponent]
pcinfo
, [KnownPackage] -> Syntax
syntaxForm1Package [KnownPackage]
pinfo
]
]
, [KnownComponent] -> Syntax
syntaxForm1Component [KnownComponent]
ocinfo
, [KnownComponent] -> Syntax
syntaxForm1Module [KnownComponent]
cinfo
, [KnownPackage] -> Syntax
syntaxForm1File [KnownPackage]
pinfo
]
,
Syntax
syntaxForm2MetaAll
, Syntax
syntaxForm2AllFilter
, [KnownPackage] -> Syntax
syntaxForm2NamespacePackage [KnownPackage]
pinfo
, [KnownPackage] -> Syntax
syntaxForm2PackageComponent [KnownPackage]
pinfo
, [KnownPackage] -> Syntax
syntaxForm2PackageFilter [KnownPackage]
pinfo
, [KnownComponent] -> Syntax
syntaxForm2KindComponent [KnownComponent]
cinfo
, [Syntax] -> Syntax
shadowingAlternatives
[ [KnownPackage] -> Syntax
syntaxForm2PackageModule [KnownPackage]
pinfo
, [KnownPackage] -> Syntax
syntaxForm2PackageFile [KnownPackage]
pinfo
]
, [Syntax] -> Syntax
shadowingAlternatives
[ [KnownComponent] -> Syntax
syntaxForm2ComponentModule [KnownComponent]
cinfo
, [KnownComponent] -> Syntax
syntaxForm2ComponentFile [KnownComponent]
cinfo
]
,
[KnownPackage] -> Syntax
syntaxForm3PackageKindComponent [KnownPackage]
pinfo
, [Syntax] -> Syntax
shadowingAlternatives
[ [KnownPackage] -> Syntax
syntaxForm3PackageComponentModule [KnownPackage]
pinfo
, [KnownPackage] -> Syntax
syntaxForm3PackageComponentFile [KnownPackage]
pinfo
]
, [Syntax] -> Syntax
shadowingAlternatives
[ [KnownComponent] -> Syntax
syntaxForm3KindComponentModule [KnownComponent]
cinfo
, [KnownComponent] -> Syntax
syntaxForm3KindComponentFile [KnownComponent]
cinfo
]
, [KnownPackage] -> Syntax
syntaxForm3NamespacePackageFilter [KnownPackage]
pinfo
,
Syntax
syntaxForm3MetaAllFilter
, [KnownPackage] -> Syntax
syntaxForm3MetaCwdFilter [KnownPackage]
ppinfo
,
[KnownPackage] -> Syntax
syntaxForm3MetaNamespacePackage [KnownPackage]
pinfo
, [KnownPackage] -> Syntax
syntaxForm4MetaNamespacePackageFilter [KnownPackage]
pinfo
,
[KnownPackage] -> Syntax
syntaxForm5MetaNamespacePackageKindComponent [KnownPackage]
pinfo
, [KnownPackage] -> Syntax
syntaxForm7MetaNamespacePackageKindComponentNamespaceModule [KnownPackage]
pinfo
, [KnownPackage] -> Syntax
syntaxForm7MetaNamespacePackageKindComponentNamespaceFile [KnownPackage]
pinfo
]
where
ambiguousAlternatives :: [Syntax] -> Syntax
ambiguousAlternatives = (Syntax -> Syntax -> Syntax) -> [Syntax] -> Syntax
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
Prelude.foldr1 Syntax -> Syntax -> Syntax
AmbiguousAlternatives
shadowingAlternatives :: [Syntax] -> Syntax
shadowingAlternatives = (Syntax -> Syntax -> Syntax) -> [Syntax] -> Syntax
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
Prelude.foldr1 Syntax -> Syntax -> Syntax
ShadowingAlternatives
syntaxForm1All :: Syntax
syntaxForm1All :: Syntax
syntaxForm1All =
(TargetSelector -> [TargetStringFileStatus]) -> Match1 -> Syntax
syntaxForm1 TargetSelector -> [TargetStringFileStatus]
render (Match1 -> Syntax) -> Match1 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 -> do
[Char] -> Match ()
guardMetaAll [Char]
str1
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe ComponentKind -> TargetSelector
TargetAllPackages Maybe ComponentKind
forall a. Maybe a
Nothing)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetAllPackages Maybe ComponentKind
Nothing) =
[[Char] -> FileStatus -> TargetStringFileStatus
TargetStringFileStatus1 [Char]
"all" FileStatus
noFileStatus]
render TargetSelector
_ = []
syntaxForm1Filter :: [KnownPackage] -> Syntax
syntaxForm1Filter :: [KnownPackage] -> Syntax
syntaxForm1Filter [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match1 -> Syntax
syntaxForm1 TargetSelector -> [TargetStringFileStatus]
render (Match1 -> Syntax) -> Match1 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 -> do
kfilter <- [Char] -> Match ComponentKind
matchComponentKindFilter [Char]
str1
return (TargetPackage TargetImplicitCwd pids (Just kfilter))
where
pids :: [PackageIdentifier]
pids = [PackageIdentifier
pinfoId | KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId} <- [KnownPackage]
ps]
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetPackage TargetImplicitCwd
TargetImplicitCwd [PackageIdentifier]
_ (Just ComponentKind
kfilter)) =
[[Char] -> FileStatus -> TargetStringFileStatus
TargetStringFileStatus1 (ComponentKind -> [Char]
dispF ComponentKind
kfilter) FileStatus
noFileStatus]
render TargetSelector
_ = []
syntaxForm1Package :: [KnownPackage] -> Syntax
syntaxForm1Package :: [KnownPackage] -> Syntax
syntaxForm1Package [KnownPackage]
pinfo =
(TargetSelector -> [TargetStringFileStatus]) -> Match1 -> Syntax
syntaxForm1 TargetSelector -> [TargetStringFileStatus]
render (Match1 -> Syntax) -> Match1 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
fstatus1 -> do
[Char] -> FileStatus -> Match ()
guardPackage [Char]
str1 FileStatus
fstatus1
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
pinfo [Char]
str1 FileStatus
fstatus1
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId} ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (TargetImplicitCwd
-> [PackageIdentifier] -> Maybe ComponentKind -> TargetSelector
TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
pinfoId] Maybe ComponentKind
forall a. Maybe a
Nothing)
KnownPackageName PackageName
pn ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName -> Maybe ComponentKind -> TargetSelector
TargetPackageNamed PackageName
pn Maybe ComponentKind
forall a. Maybe a
Nothing)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
p] Maybe ComponentKind
Nothing) =
[[Char] -> FileStatus -> TargetStringFileStatus
TargetStringFileStatus1 (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) FileStatus
noFileStatus]
render (TargetPackageNamed PackageName
pn Maybe ComponentKind
Nothing) =
[[Char] -> FileStatus -> TargetStringFileStatus
TargetStringFileStatus1 (PackageName -> [Char]
dispPN PackageName
pn) FileStatus
noFileStatus]
render TargetSelector
_ = []
syntaxForm1Component :: [KnownComponent] -> Syntax
syntaxForm1Component :: [KnownComponent] -> Syntax
syntaxForm1Component [KnownComponent]
cs =
(TargetSelector -> [TargetStringFileStatus]) -> Match1 -> Syntax
syntaxForm1 TargetSelector -> [TargetStringFileStatus]
render (Match1 -> Syntax) -> Match1 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 -> do
[Char] -> Match ()
guardComponentName [Char]
str1
c <- [KnownComponent] -> [Char] -> Match KnownComponent
matchComponentName [KnownComponent]
cs [Char]
str1
return (TargetComponent (cinfoPackageId c) (cinfoName c) WholeComponent)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c SubComponentTarget
WholeComponent) =
[[Char] -> FileStatus -> TargetStringFileStatus
TargetStringFileStatus1 (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c) FileStatus
noFileStatus]
render TargetSelector
_ = []
syntaxForm1Module :: [KnownComponent] -> Syntax
syntaxForm1Module :: [KnownComponent] -> Syntax
syntaxForm1Module [KnownComponent]
cs =
(TargetSelector -> [TargetStringFileStatus]) -> Match1 -> Syntax
syntaxForm1 TargetSelector -> [TargetStringFileStatus]
render (Match1 -> Syntax) -> Match1 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 -> do
[Char] -> Match ()
guardModuleName [Char]
str1
let ms :: [(ModuleName, KnownComponent)]
ms = [(ModuleName
m, KnownComponent
c) | KnownComponent
c <- [KnownComponent]
cs, ModuleName
m <- KnownComponent -> [ModuleName]
cinfoModules KnownComponent
c]
(m, c) <- [(ModuleName, KnownComponent)]
-> [Char] -> Match (ModuleName, KnownComponent)
forall a. [(ModuleName, a)] -> [Char] -> Match (ModuleName, a)
matchModuleNameAnd [(ModuleName, KnownComponent)]
ms [Char]
str1
return (TargetComponent (cinfoPackageId c) (cinfoName c) (ModuleTarget m))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
_p ComponentName
_c (ModuleTarget ModuleName
m)) =
[[Char] -> FileStatus -> TargetStringFileStatus
TargetStringFileStatus1 (ModuleName -> [Char]
dispM ModuleName
m) FileStatus
noFileStatus]
render TargetSelector
_ = []
syntaxForm1File :: [KnownPackage] -> Syntax
syntaxForm1File :: [KnownPackage] -> Syntax
syntaxForm1File [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match1 -> Syntax
syntaxForm1 TargetSelector -> [TargetStringFileStatus]
render (Match1 -> Syntax) -> Match1 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
fstatus1 ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
expecting [Char]
"file" [Char]
str1 (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
(pkgfile, ~KnownPackage{pinfoId, pinfoComponents}) <-
[KnownPackage] -> FileStatus -> Match ([Char], KnownPackage)
matchPackageDirectoryPrefix [KnownPackage]
ps FileStatus
fstatus1
orNoThingIn "package" (prettyShow (packageName pinfoId)) $ do
(filepath, c) <- matchComponentFile pinfoComponents pkgfile
return (TargetComponent pinfoId (cinfoName c) (FileTarget filepath))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
_p ComponentName
_c (FileTarget [Char]
f)) =
[[Char] -> FileStatus -> TargetStringFileStatus
TargetStringFileStatus1 [Char]
f FileStatus
noFileStatus]
render TargetSelector
_ = []
syntaxForm2MetaAll :: Syntax
syntaxForm2MetaAll :: Syntax
syntaxForm2MetaAll =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 -> do
[Char] -> Match ()
guardNamespaceMeta [Char]
str1
[Char] -> Match ()
guardMetaAll [Char]
str2
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe ComponentKind -> TargetSelector
TargetAllPackages Maybe ComponentKind
forall a. Maybe a
Nothing)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetAllPackages Maybe ComponentKind
Nothing) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 [Char]
"" FileStatus
noFileStatus [Char]
"all"]
render TargetSelector
_ = []
syntaxForm2AllFilter :: Syntax
syntaxForm2AllFilter :: Syntax
syntaxForm2AllFilter =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 -> do
[Char] -> Match ()
guardMetaAll [Char]
str1
kfilter <- [Char] -> Match ComponentKind
matchComponentKindFilter [Char]
str2
return (TargetAllPackages (Just kfilter))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetAllPackages (Just ComponentKind
kfilter)) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 [Char]
"all" FileStatus
noFileStatus (ComponentKind -> [Char]
dispF ComponentKind
kfilter)]
render TargetSelector
_ = []
syntaxForm2PackageFilter :: [KnownPackage] -> Syntax
syntaxForm2PackageFilter :: [KnownPackage] -> Syntax
syntaxForm2PackageFilter [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
fstatus1 [Char]
str2 -> do
[Char] -> FileStatus -> Match ()
guardPackage [Char]
str1 FileStatus
fstatus1
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
ps [Char]
str1 FileStatus
fstatus1
kfilter <- matchComponentKindFilter str2
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId} ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (TargetImplicitCwd
-> [PackageIdentifier] -> Maybe ComponentKind -> TargetSelector
TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
pinfoId] (ComponentKind -> Maybe ComponentKind
forall a. a -> Maybe a
Just ComponentKind
kfilter))
KnownPackageName PackageName
pn ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName -> Maybe ComponentKind -> TargetSelector
TargetPackageNamed PackageName
pn (ComponentKind -> Maybe ComponentKind
forall a. a -> Maybe a
Just ComponentKind
kfilter))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
p] (Just ComponentKind
kfilter)) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) FileStatus
noFileStatus (ComponentKind -> [Char]
dispF ComponentKind
kfilter)]
render (TargetPackageNamed PackageName
pn (Just ComponentKind
kfilter)) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 (PackageName -> [Char]
dispPN PackageName
pn) FileStatus
noFileStatus (ComponentKind -> [Char]
dispF ComponentKind
kfilter)]
render TargetSelector
_ = []
syntaxForm2NamespacePackage :: [KnownPackage] -> Syntax
syntaxForm2NamespacePackage :: [KnownPackage] -> Syntax
syntaxForm2NamespacePackage [KnownPackage]
pinfo =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 -> do
[Char] -> Match ()
guardNamespacePackage [Char]
str1
[Char] -> Match ()
guardPackageName [Char]
str2
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
pinfo [Char]
str2 FileStatus
noFileStatus
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId} ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (TargetImplicitCwd
-> [PackageIdentifier] -> Maybe ComponentKind -> TargetSelector
TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
pinfoId] Maybe ComponentKind
forall a. Maybe a
Nothing)
KnownPackageName PackageName
pn ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName -> Maybe ComponentKind -> TargetSelector
TargetPackageNamed PackageName
pn Maybe ComponentKind
forall a. Maybe a
Nothing)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
p] Maybe ComponentKind
Nothing) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 [Char]
"pkg" FileStatus
noFileStatus (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p)]
render (TargetPackageNamed PackageName
pn Maybe ComponentKind
Nothing) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 [Char]
"pkg" FileStatus
noFileStatus (PackageName -> [Char]
dispPN PackageName
pn)]
render TargetSelector
_ = []
syntaxForm2PackageComponent :: [KnownPackage] -> Syntax
syntaxForm2PackageComponent :: [KnownPackage] -> Syntax
syntaxForm2PackageComponent [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
fstatus1 [Char]
str2 -> do
[Char] -> FileStatus -> Match ()
guardPackage [Char]
str1 FileStatus
fstatus1
[Char] -> Match ()
guardComponentName [Char]
str2
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
ps [Char]
str1 FileStatus
fstatus1
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId, [KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"package" (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId)) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
c <- [KnownComponent] -> [Char] -> Match KnownComponent
matchComponentName [KnownComponent]
pinfoComponents [Char]
str2
return (TargetComponent pinfoId (cinfoName c) WholeComponent)
KnownPackageName PackageName
pn ->
let cn :: UnqualComponentName
cn = [Char] -> UnqualComponentName
mkUnqualComponentName [Char]
str2
in TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName
-> Either UnqualComponentName ComponentName
-> SubComponentTarget
-> TargetSelector
TargetComponentUnknown PackageName
pn (UnqualComponentName -> Either UnqualComponentName ComponentName
forall a b. a -> Either a b
Left UnqualComponentName
cn) SubComponentTarget
WholeComponent)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c SubComponentTarget
WholeComponent) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) FileStatus
noFileStatus (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c)]
render (TargetComponentUnknown PackageName
pn (Left UnqualComponentName
cn) SubComponentTarget
WholeComponent) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 (PackageName -> [Char]
dispPN PackageName
pn) FileStatus
noFileStatus (UnqualComponentName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow UnqualComponentName
cn)]
render TargetSelector
_ = []
syntaxForm2KindComponent :: [KnownComponent] -> Syntax
syntaxForm2KindComponent :: [KnownComponent] -> Syntax
syntaxForm2KindComponent [KnownComponent]
cs =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 -> do
ckind <- [Char] -> Match ComponentKind
matchComponentKind [Char]
str1
guardComponentName str2
c <- matchComponentKindAndName cs ckind str2
return (TargetComponent (cinfoPackageId c) (cinfoName c) WholeComponent)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c SubComponentTarget
WholeComponent) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 (ComponentName -> [Char]
dispCK ComponentName
c) FileStatus
noFileStatus (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c)]
render TargetSelector
_ = []
syntaxForm2PackageModule :: [KnownPackage] -> Syntax
syntaxForm2PackageModule :: [KnownPackage] -> Syntax
syntaxForm2PackageModule [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
fstatus1 [Char]
str2 -> do
[Char] -> FileStatus -> Match ()
guardPackage [Char]
str1 FileStatus
fstatus1
[Char] -> Match ()
guardModuleName [Char]
str2
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
ps [Char]
str1 FileStatus
fstatus1
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId, [KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"package" (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId)) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
let ms :: [(ModuleName, KnownComponent)]
ms = [(ModuleName
m, KnownComponent
c) | KnownComponent
c <- [KnownComponent]
pinfoComponents, ModuleName
m <- KnownComponent -> [ModuleName]
cinfoModules KnownComponent
c]
(m, c) <- [(ModuleName, KnownComponent)]
-> [Char] -> Match (ModuleName, KnownComponent)
forall a. [(ModuleName, a)] -> [Char] -> Match (ModuleName, a)
matchModuleNameAnd [(ModuleName, KnownComponent)]
ms [Char]
str2
return (TargetComponent pinfoId (cinfoName c) (ModuleTarget m))
KnownPackageName PackageName
pn -> do
m <- [Char] -> Match ModuleName
matchModuleNameUnknown [Char]
str2
return (TargetComponentUnknown pn (Right $ CLibName LMainLibName) (ModuleTarget m))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
_c (ModuleTarget ModuleName
m)) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) FileStatus
noFileStatus (ModuleName -> [Char]
dispM ModuleName
m)]
render TargetSelector
_ = []
syntaxForm2ComponentModule :: [KnownComponent] -> Syntax
syntaxForm2ComponentModule :: [KnownComponent] -> Syntax
syntaxForm2ComponentModule [KnownComponent]
cs =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 -> do
[Char] -> Match ()
guardComponentName [Char]
str1
[Char] -> Match ()
guardModuleName [Char]
str2
c <- [KnownComponent] -> [Char] -> Match KnownComponent
matchComponentName [KnownComponent]
cs [Char]
str1
orNoThingIn "component" (cinfoStrName c) $ do
let ms = KnownComponent -> [ModuleName]
cinfoModules KnownComponent
c
m <- matchModuleName ms str2
return
( TargetComponent
(cinfoPackageId c)
(cinfoName c)
(ModuleTarget m)
)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c (ModuleTarget ModuleName
m)) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c) FileStatus
noFileStatus (ModuleName -> [Char]
dispM ModuleName
m)]
render TargetSelector
_ = []
syntaxForm2PackageFile :: [KnownPackage] -> Syntax
syntaxForm2PackageFile :: [KnownPackage] -> Syntax
syntaxForm2PackageFile [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
fstatus1 [Char]
str2 -> do
[Char] -> FileStatus -> Match ()
guardPackage [Char]
str1 FileStatus
fstatus1
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
ps [Char]
str1 FileStatus
fstatus1
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId, [KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"package" (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId)) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
(filepath, c) <- [KnownComponent] -> [Char] -> Match ([Char], KnownComponent)
matchComponentFile [KnownComponent]
pinfoComponents [Char]
str2
return (TargetComponent pinfoId (cinfoName c) (FileTarget filepath))
KnownPackageName PackageName
pn ->
let filepath :: [Char]
filepath = [Char]
str2
in
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName
-> Either UnqualComponentName ComponentName
-> SubComponentTarget
-> TargetSelector
TargetComponentUnknown PackageName
pn (ComponentName -> Either UnqualComponentName ComponentName
forall a b. b -> Either a b
Right (ComponentName -> Either UnqualComponentName ComponentName)
-> ComponentName -> Either UnqualComponentName ComponentName
forall a b. (a -> b) -> a -> b
$ LibraryName -> ComponentName
CLibName LibraryName
LMainLibName) ([Char] -> SubComponentTarget
FileTarget [Char]
filepath))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
_c (FileTarget [Char]
f)) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) FileStatus
noFileStatus [Char]
f]
render TargetSelector
_ = []
syntaxForm2ComponentFile :: [KnownComponent] -> Syntax
syntaxForm2ComponentFile :: [KnownComponent] -> Syntax
syntaxForm2ComponentFile [KnownComponent]
cs =
(TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render (Match2 -> Syntax) -> Match2 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 -> do
[Char] -> Match ()
guardComponentName [Char]
str1
c <- [KnownComponent] -> [Char] -> Match KnownComponent
matchComponentName [KnownComponent]
cs [Char]
str1
orNoThingIn "component" (cinfoStrName c) $ do
(filepath, _) <- matchComponentFile [c] str2
return
( TargetComponent
(cinfoPackageId c)
(cinfoName c)
(FileTarget filepath)
)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c (FileTarget [Char]
f)) =
[[Char] -> FileStatus -> [Char] -> TargetStringFileStatus
TargetStringFileStatus2 (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c) FileStatus
noFileStatus [Char]
f]
render TargetSelector
_ = []
syntaxForm3MetaAllFilter :: Syntax
syntaxForm3MetaAllFilter :: Syntax
syntaxForm3MetaAllFilter =
(TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render (Match3 -> Syntax) -> Match3 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 [Char]
str3 -> do
[Char] -> Match ()
guardNamespaceMeta [Char]
str1
[Char] -> Match ()
guardMetaAll [Char]
str2
kfilter <- [Char] -> Match ComponentKind
matchComponentKindFilter [Char]
str3
return (TargetAllPackages (Just kfilter))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetAllPackages (Just ComponentKind
kfilter)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 [Char]
"" FileStatus
noFileStatus [Char]
"all" (ComponentKind -> [Char]
dispF ComponentKind
kfilter)]
render TargetSelector
_ = []
syntaxForm3MetaCwdFilter :: [KnownPackage] -> Syntax
syntaxForm3MetaCwdFilter :: [KnownPackage] -> Syntax
syntaxForm3MetaCwdFilter [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render (Match3 -> Syntax) -> Match3 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 [Char]
str3 -> do
[Char] -> Match ()
guardNamespaceMeta [Char]
str1
[Char] -> Match ()
guardNamespaceCwd [Char]
str2
kfilter <- [Char] -> Match ComponentKind
matchComponentKindFilter [Char]
str3
return (TargetPackage TargetImplicitCwd pids (Just kfilter))
where
pids :: [PackageIdentifier]
pids = [PackageIdentifier
pinfoId | KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId} <- [KnownPackage]
ps]
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetPackage TargetImplicitCwd
TargetImplicitCwd [PackageIdentifier]
_ (Just ComponentKind
kfilter)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 [Char]
"" FileStatus
noFileStatus [Char]
"cwd" (ComponentKind -> [Char]
dispF ComponentKind
kfilter)]
render TargetSelector
_ = []
syntaxForm3MetaNamespacePackage :: [KnownPackage] -> Syntax
syntaxForm3MetaNamespacePackage :: [KnownPackage] -> Syntax
syntaxForm3MetaNamespacePackage [KnownPackage]
pinfo =
(TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render (Match3 -> Syntax) -> Match3 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 [Char]
str3 -> do
[Char] -> Match ()
guardNamespaceMeta [Char]
str1
[Char] -> Match ()
guardNamespacePackage [Char]
str2
[Char] -> Match ()
guardPackageName [Char]
str3
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
pinfo [Char]
str3 FileStatus
noFileStatus
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId} ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (TargetImplicitCwd
-> [PackageIdentifier] -> Maybe ComponentKind -> TargetSelector
TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
pinfoId] Maybe ComponentKind
forall a. Maybe a
Nothing)
KnownPackageName PackageName
pn ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName -> Maybe ComponentKind -> TargetSelector
TargetPackageNamed PackageName
pn Maybe ComponentKind
forall a. Maybe a
Nothing)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
p] Maybe ComponentKind
Nothing) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 [Char]
"" FileStatus
noFileStatus [Char]
"pkg" (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p)]
render (TargetPackageNamed PackageName
pn Maybe ComponentKind
Nothing) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 [Char]
"" FileStatus
noFileStatus [Char]
"pkg" (PackageName -> [Char]
dispPN PackageName
pn)]
render TargetSelector
_ = []
syntaxForm3PackageKindComponent :: [KnownPackage] -> Syntax
syntaxForm3PackageKindComponent :: [KnownPackage] -> Syntax
syntaxForm3PackageKindComponent [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render (Match3 -> Syntax) -> Match3 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
fstatus1 [Char]
str2 [Char]
str3 -> do
[Char] -> FileStatus -> Match ()
guardPackage [Char]
str1 FileStatus
fstatus1
ckind <- [Char] -> Match ComponentKind
matchComponentKind [Char]
str2
guardComponentName str3
p <- matchPackage ps str1 fstatus1
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId, [KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"package" (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId)) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
c <- [KnownComponent] -> ComponentKind -> [Char] -> Match KnownComponent
matchComponentKindAndName [KnownComponent]
pinfoComponents ComponentKind
ckind [Char]
str3
return (TargetComponent pinfoId (cinfoName c) WholeComponent)
KnownPackageName PackageName
pn ->
let cn :: ComponentName
cn = PackageName
-> ComponentKind -> UnqualComponentName -> ComponentName
mkComponentName PackageName
pn ComponentKind
ckind ([Char] -> UnqualComponentName
mkUnqualComponentName [Char]
str3)
in TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName
-> Either UnqualComponentName ComponentName
-> SubComponentTarget
-> TargetSelector
TargetComponentUnknown PackageName
pn (ComponentName -> Either UnqualComponentName ComponentName
forall a b. b -> Either a b
Right ComponentName
cn) SubComponentTarget
WholeComponent)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c SubComponentTarget
WholeComponent) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) FileStatus
noFileStatus (ComponentName -> [Char]
dispCK ComponentName
c) (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c)]
render (TargetComponentUnknown PackageName
pn (Right ComponentName
c) SubComponentTarget
WholeComponent) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 (PackageName -> [Char]
dispPN PackageName
pn) FileStatus
noFileStatus (ComponentName -> [Char]
dispCK ComponentName
c) (PackageName -> ComponentName -> [Char]
dispC' PackageName
pn ComponentName
c)]
render TargetSelector
_ = []
syntaxForm3PackageComponentModule :: [KnownPackage] -> Syntax
syntaxForm3PackageComponentModule :: [KnownPackage] -> Syntax
syntaxForm3PackageComponentModule [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render (Match3 -> Syntax) -> Match3 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
fstatus1 [Char]
str2 [Char]
str3 -> do
[Char] -> FileStatus -> Match ()
guardPackage [Char]
str1 FileStatus
fstatus1
[Char] -> Match ()
guardComponentName [Char]
str2
[Char] -> Match ()
guardModuleName [Char]
str3
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
ps [Char]
str1 FileStatus
fstatus1
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId, [KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"package" (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId)) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
c <- [KnownComponent] -> [Char] -> Match KnownComponent
matchComponentName [KnownComponent]
pinfoComponents [Char]
str2
orNoThingIn "component" (cinfoStrName c) $ do
let ms = KnownComponent -> [ModuleName]
cinfoModules KnownComponent
c
m <- matchModuleName ms str3
return (TargetComponent pinfoId (cinfoName c) (ModuleTarget m))
KnownPackageName PackageName
pn -> do
let cn :: UnqualComponentName
cn = [Char] -> UnqualComponentName
mkUnqualComponentName [Char]
str2
m <- [Char] -> Match ModuleName
matchModuleNameUnknown [Char]
str3
return (TargetComponentUnknown pn (Left cn) (ModuleTarget m))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c (ModuleTarget ModuleName
m)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) FileStatus
noFileStatus (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c) (ModuleName -> [Char]
dispM ModuleName
m)]
render (TargetComponentUnknown PackageName
pn (Left UnqualComponentName
c) (ModuleTarget ModuleName
m)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 (PackageName -> [Char]
dispPN PackageName
pn) FileStatus
noFileStatus (UnqualComponentName -> [Char]
dispCN UnqualComponentName
c) (ModuleName -> [Char]
dispM ModuleName
m)]
render TargetSelector
_ = []
syntaxForm3KindComponentModule :: [KnownComponent] -> Syntax
syntaxForm3KindComponentModule :: [KnownComponent] -> Syntax
syntaxForm3KindComponentModule [KnownComponent]
cs =
(TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render (Match3 -> Syntax) -> Match3 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 [Char]
str3 -> do
ckind <- [Char] -> Match ComponentKind
matchComponentKind [Char]
str1
guardComponentName str2
guardModuleName str3
c <- matchComponentKindAndName cs ckind str2
orNoThingIn "component" (cinfoStrName c) $ do
let ms = KnownComponent -> [ModuleName]
cinfoModules KnownComponent
c
m <- matchModuleName ms str3
return
( TargetComponent
(cinfoPackageId c)
(cinfoName c)
(ModuleTarget m)
)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c (ModuleTarget ModuleName
m)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 (ComponentName -> [Char]
dispCK ComponentName
c) FileStatus
noFileStatus (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c) (ModuleName -> [Char]
dispM ModuleName
m)]
render TargetSelector
_ = []
syntaxForm3PackageComponentFile :: [KnownPackage] -> Syntax
syntaxForm3PackageComponentFile :: [KnownPackage] -> Syntax
syntaxForm3PackageComponentFile [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render (Match3 -> Syntax) -> Match3 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
fstatus1 [Char]
str2 [Char]
str3 -> do
[Char] -> FileStatus -> Match ()
guardPackage [Char]
str1 FileStatus
fstatus1
[Char] -> Match ()
guardComponentName [Char]
str2
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
ps [Char]
str1 FileStatus
fstatus1
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId, [KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"package" (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId)) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
c <- [KnownComponent] -> [Char] -> Match KnownComponent
matchComponentName [KnownComponent]
pinfoComponents [Char]
str2
orNoThingIn "component" (cinfoStrName c) $ do
(filepath, _) <- matchComponentFile [c] str3
return (TargetComponent pinfoId (cinfoName c) (FileTarget filepath))
KnownPackageName PackageName
pn ->
let cn :: UnqualComponentName
cn = [Char] -> UnqualComponentName
mkUnqualComponentName [Char]
str2
filepath :: [Char]
filepath = [Char]
str3
in TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName
-> Either UnqualComponentName ComponentName
-> SubComponentTarget
-> TargetSelector
TargetComponentUnknown PackageName
pn (UnqualComponentName -> Either UnqualComponentName ComponentName
forall a b. a -> Either a b
Left UnqualComponentName
cn) ([Char] -> SubComponentTarget
FileTarget [Char]
filepath))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c (FileTarget [Char]
f)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) FileStatus
noFileStatus (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c) [Char]
f]
render (TargetComponentUnknown PackageName
pn (Left UnqualComponentName
c) (FileTarget [Char]
f)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 (PackageName -> [Char]
dispPN PackageName
pn) FileStatus
noFileStatus (UnqualComponentName -> [Char]
dispCN UnqualComponentName
c) [Char]
f]
render TargetSelector
_ = []
syntaxForm3KindComponentFile :: [KnownComponent] -> Syntax
syntaxForm3KindComponentFile :: [KnownComponent] -> Syntax
syntaxForm3KindComponentFile [KnownComponent]
cs =
(TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render (Match3 -> Syntax) -> Match3 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 [Char]
str3 -> do
ckind <- [Char] -> Match ComponentKind
matchComponentKind [Char]
str1
guardComponentName str2
c <- matchComponentKindAndName cs ckind str2
orNoThingIn "component" (cinfoStrName c) $ do
(filepath, _) <- matchComponentFile [c] str3
return
( TargetComponent
(cinfoPackageId c)
(cinfoName c)
(FileTarget filepath)
)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c (FileTarget [Char]
f)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 (ComponentName -> [Char]
dispCK ComponentName
c) FileStatus
noFileStatus (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c) [Char]
f]
render TargetSelector
_ = []
syntaxForm3NamespacePackageFilter :: [KnownPackage] -> Syntax
syntaxForm3NamespacePackageFilter :: [KnownPackage] -> Syntax
syntaxForm3NamespacePackageFilter [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render (Match3 -> Syntax) -> Match3 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 FileStatus
_fstatus1 [Char]
str2 [Char]
str3 -> do
[Char] -> Match ()
guardNamespacePackage [Char]
str1
[Char] -> Match ()
guardPackageName [Char]
str2
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
ps [Char]
str2 FileStatus
noFileStatus
kfilter <- matchComponentKindFilter str3
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId} ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (TargetImplicitCwd
-> [PackageIdentifier] -> Maybe ComponentKind -> TargetSelector
TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
pinfoId] (ComponentKind -> Maybe ComponentKind
forall a. a -> Maybe a
Just ComponentKind
kfilter))
KnownPackageName PackageName
pn ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName -> Maybe ComponentKind -> TargetSelector
TargetPackageNamed PackageName
pn (ComponentKind -> Maybe ComponentKind
forall a. a -> Maybe a
Just ComponentKind
kfilter))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
p] (Just ComponentKind
kfilter)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 [Char]
"pkg" FileStatus
noFileStatus (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) (ComponentKind -> [Char]
dispF ComponentKind
kfilter)]
render (TargetPackageNamed PackageName
pn (Just ComponentKind
kfilter)) =
[[Char] -> FileStatus -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus3 [Char]
"pkg" FileStatus
noFileStatus (PackageName -> [Char]
dispPN PackageName
pn) (ComponentKind -> [Char]
dispF ComponentKind
kfilter)]
render TargetSelector
_ = []
syntaxForm4MetaNamespacePackageFilter :: [KnownPackage] -> Syntax
syntaxForm4MetaNamespacePackageFilter :: [KnownPackage] -> Syntax
syntaxForm4MetaNamespacePackageFilter [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match4 -> Syntax
syntaxForm4 TargetSelector -> [TargetStringFileStatus]
render (Match4 -> Syntax) -> Match4 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4 -> do
[Char] -> Match ()
guardNamespaceMeta [Char]
str1
[Char] -> Match ()
guardNamespacePackage [Char]
str2
[Char] -> Match ()
guardPackageName [Char]
str3
p <- [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
ps [Char]
str3 FileStatus
noFileStatus
kfilter <- matchComponentKindFilter str4
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId} ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (TargetImplicitCwd
-> [PackageIdentifier] -> Maybe ComponentKind -> TargetSelector
TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
pinfoId] (ComponentKind -> Maybe ComponentKind
forall a. a -> Maybe a
Just ComponentKind
kfilter))
KnownPackageName PackageName
pn ->
TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName -> Maybe ComponentKind -> TargetSelector
TargetPackageNamed PackageName
pn (ComponentKind -> Maybe ComponentKind
forall a. a -> Maybe a
Just ComponentKind
kfilter))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetPackage TargetImplicitCwd
TargetExplicitNamed [PackageIdentifier
p] (Just ComponentKind
kfilter)) =
[[Char] -> [Char] -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus4 [Char]
"" [Char]
"pkg" (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) (ComponentKind -> [Char]
dispF ComponentKind
kfilter)]
render (TargetPackageNamed PackageName
pn (Just ComponentKind
kfilter)) =
[[Char] -> [Char] -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus4 [Char]
"" [Char]
"pkg" (PackageName -> [Char]
dispPN PackageName
pn) (ComponentKind -> [Char]
dispF ComponentKind
kfilter)]
render TargetSelector
_ = []
syntaxForm5MetaNamespacePackageKindComponent :: [KnownPackage] -> Syntax
syntaxForm5MetaNamespacePackageKindComponent :: [KnownPackage] -> Syntax
syntaxForm5MetaNamespacePackageKindComponent [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match5 -> Syntax
syntaxForm5 TargetSelector -> [TargetStringFileStatus]
render (Match5 -> Syntax) -> Match5 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4 [Char]
str5 -> do
[Char] -> Match ()
guardNamespaceMeta [Char]
str1
[Char] -> Match ()
guardNamespacePackage [Char]
str2
[Char] -> Match ()
guardPackageName [Char]
str3
ckind <- [Char] -> Match ComponentKind
matchComponentKind [Char]
str4
guardComponentName str5
p <- matchPackage ps str3 noFileStatus
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId, [KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"package" (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId)) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
c <- [KnownComponent] -> ComponentKind -> [Char] -> Match KnownComponent
matchComponentKindAndName [KnownComponent]
pinfoComponents ComponentKind
ckind [Char]
str5
return (TargetComponent pinfoId (cinfoName c) WholeComponent)
KnownPackageName PackageName
pn ->
let cn :: ComponentName
cn = PackageName
-> ComponentKind -> UnqualComponentName -> ComponentName
mkComponentName PackageName
pn ComponentKind
ckind ([Char] -> UnqualComponentName
mkUnqualComponentName [Char]
str5)
in TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName
-> Either UnqualComponentName ComponentName
-> SubComponentTarget
-> TargetSelector
TargetComponentUnknown PackageName
pn (ComponentName -> Either UnqualComponentName ComponentName
forall a b. b -> Either a b
Right ComponentName
cn) SubComponentTarget
WholeComponent)
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c SubComponentTarget
WholeComponent) =
[[Char]
-> [Char] -> [Char] -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus5 [Char]
"" [Char]
"pkg" (PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p) (ComponentName -> [Char]
dispCK ComponentName
c) (PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c)]
render (TargetComponentUnknown PackageName
pn (Right ComponentName
c) SubComponentTarget
WholeComponent) =
[[Char]
-> [Char] -> [Char] -> [Char] -> [Char] -> TargetStringFileStatus
TargetStringFileStatus5 [Char]
"" [Char]
"pkg" (PackageName -> [Char]
dispPN PackageName
pn) (ComponentName -> [Char]
dispCK ComponentName
c) (PackageName -> ComponentName -> [Char]
dispC' PackageName
pn ComponentName
c)]
render TargetSelector
_ = []
syntaxForm7MetaNamespacePackageKindComponentNamespaceModule
:: [KnownPackage] -> Syntax
syntaxForm7MetaNamespacePackageKindComponentNamespaceModule :: [KnownPackage] -> Syntax
syntaxForm7MetaNamespacePackageKindComponentNamespaceModule [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match7 -> Syntax
syntaxForm7 TargetSelector -> [TargetStringFileStatus]
render (Match7 -> Syntax) -> Match7 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4 [Char]
str5 [Char]
str6 [Char]
str7 -> do
[Char] -> Match ()
guardNamespaceMeta [Char]
str1
[Char] -> Match ()
guardNamespacePackage [Char]
str2
[Char] -> Match ()
guardPackageName [Char]
str3
ckind <- [Char] -> Match ComponentKind
matchComponentKind [Char]
str4
guardComponentName str5
guardNamespaceModule str6
p <- matchPackage ps str3 noFileStatus
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId, [KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"package" (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId)) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
c <- [KnownComponent] -> ComponentKind -> [Char] -> Match KnownComponent
matchComponentKindAndName [KnownComponent]
pinfoComponents ComponentKind
ckind [Char]
str5
orNoThingIn "component" (cinfoStrName c) $ do
let ms = KnownComponent -> [ModuleName]
cinfoModules KnownComponent
c
m <- matchModuleName ms str7
return (TargetComponent pinfoId (cinfoName c) (ModuleTarget m))
KnownPackageName PackageName
pn -> do
let cn :: ComponentName
cn = PackageName
-> ComponentKind -> UnqualComponentName -> ComponentName
mkComponentName PackageName
pn ComponentKind
ckind ([Char] -> UnqualComponentName
mkUnqualComponentName [Char]
str2)
m <- [Char] -> Match ModuleName
matchModuleNameUnknown [Char]
str7
return (TargetComponentUnknown pn (Right cn) (ModuleTarget m))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c (ModuleTarget ModuleName
m)) =
[ [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> TargetStringFileStatus
TargetStringFileStatus7
[Char]
""
[Char]
"pkg"
(PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p)
(ComponentName -> [Char]
dispCK ComponentName
c)
(PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c)
[Char]
"module"
(ModuleName -> [Char]
dispM ModuleName
m)
]
render (TargetComponentUnknown PackageName
pn (Right ComponentName
c) (ModuleTarget ModuleName
m)) =
[ [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> TargetStringFileStatus
TargetStringFileStatus7
[Char]
""
[Char]
"pkg"
(PackageName -> [Char]
dispPN PackageName
pn)
(ComponentName -> [Char]
dispCK ComponentName
c)
(PackageName -> ComponentName -> [Char]
dispC' PackageName
pn ComponentName
c)
[Char]
"module"
(ModuleName -> [Char]
dispM ModuleName
m)
]
render TargetSelector
_ = []
syntaxForm7MetaNamespacePackageKindComponentNamespaceFile
:: [KnownPackage] -> Syntax
syntaxForm7MetaNamespacePackageKindComponentNamespaceFile :: [KnownPackage] -> Syntax
syntaxForm7MetaNamespacePackageKindComponentNamespaceFile [KnownPackage]
ps =
(TargetSelector -> [TargetStringFileStatus]) -> Match7 -> Syntax
syntaxForm7 TargetSelector -> [TargetStringFileStatus]
render (Match7 -> Syntax) -> Match7 -> Syntax
forall a b. (a -> b) -> a -> b
$ \[Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4 [Char]
str5 [Char]
str6 [Char]
str7 -> do
[Char] -> Match ()
guardNamespaceMeta [Char]
str1
[Char] -> Match ()
guardNamespacePackage [Char]
str2
[Char] -> Match ()
guardPackageName [Char]
str3
ckind <- [Char] -> Match ComponentKind
matchComponentKind [Char]
str4
guardComponentName str5
guardNamespaceFile str6
p <- matchPackage ps str3 noFileStatus
case p of
KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId, [KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} ->
[Char] -> [Char] -> Match TargetSelector -> Match TargetSelector
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"package" (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId)) (Match TargetSelector -> Match TargetSelector)
-> Match TargetSelector -> Match TargetSelector
forall a b. (a -> b) -> a -> b
$ do
c <- [KnownComponent] -> ComponentKind -> [Char] -> Match KnownComponent
matchComponentKindAndName [KnownComponent]
pinfoComponents ComponentKind
ckind [Char]
str5
orNoThingIn "component" (cinfoStrName c) $ do
(filepath, _) <- matchComponentFile [c] str7
return (TargetComponent pinfoId (cinfoName c) (FileTarget filepath))
KnownPackageName PackageName
pn ->
let cn :: ComponentName
cn = PackageName
-> ComponentKind -> UnqualComponentName -> ComponentName
mkComponentName PackageName
pn ComponentKind
ckind ([Char] -> UnqualComponentName
mkUnqualComponentName [Char]
str5)
filepath :: [Char]
filepath = [Char]
str7
in TargetSelector -> Match TargetSelector
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName
-> Either UnqualComponentName ComponentName
-> SubComponentTarget
-> TargetSelector
TargetComponentUnknown PackageName
pn (ComponentName -> Either UnqualComponentName ComponentName
forall a b. b -> Either a b
Right ComponentName
cn) ([Char] -> SubComponentTarget
FileTarget [Char]
filepath))
where
render :: TargetSelector -> [TargetStringFileStatus]
render (TargetComponent PackageIdentifier
p ComponentName
c (FileTarget [Char]
f)) =
[ [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> TargetStringFileStatus
TargetStringFileStatus7
[Char]
""
[Char]
"pkg"
(PackageIdentifier -> [Char]
forall p. Package p => p -> [Char]
dispP PackageIdentifier
p)
(ComponentName -> [Char]
dispCK ComponentName
c)
(PackageIdentifier -> ComponentName -> [Char]
dispC PackageIdentifier
p ComponentName
c)
[Char]
"file"
[Char]
f
]
render (TargetComponentUnknown PackageName
pn (Right ComponentName
c) (FileTarget [Char]
f)) =
[ [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> TargetStringFileStatus
TargetStringFileStatus7
[Char]
""
[Char]
"pkg"
(PackageName -> [Char]
dispPN PackageName
pn)
(ComponentName -> [Char]
dispCK ComponentName
c)
(PackageName -> ComponentName -> [Char]
dispC' PackageName
pn ComponentName
c)
[Char]
"file"
[Char]
f
]
render TargetSelector
_ = []
type Match1 = String -> FileStatus -> Match TargetSelector
type Match2 =
String
-> FileStatus
-> String
-> Match TargetSelector
type Match3 =
String
-> FileStatus
-> String
-> String
-> Match TargetSelector
type Match4 =
String
-> String
-> String
-> String
-> Match TargetSelector
type Match5 =
String
-> String
-> String
-> String
-> String
-> Match TargetSelector
type Match7 =
String
-> String
-> String
-> String
-> String
-> String
-> String
-> Match TargetSelector
syntaxForm1 :: Renderer -> Match1 -> Syntax
syntaxForm2 :: Renderer -> Match2 -> Syntax
syntaxForm3 :: Renderer -> Match3 -> Syntax
syntaxForm4 :: Renderer -> Match4 -> Syntax
syntaxForm5 :: Renderer -> Match5 -> Syntax
syntaxForm7 :: Renderer -> Match7 -> Syntax
syntaxForm1 :: (TargetSelector -> [TargetStringFileStatus]) -> Match1 -> Syntax
syntaxForm1 TargetSelector -> [TargetStringFileStatus]
render Match1
f =
QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> Syntax
Syntax QualLevel
QL1 TargetStringFileStatus -> Match TargetSelector
match TargetSelector -> [TargetStringFileStatus]
render
where
match :: TargetStringFileStatus -> Match TargetSelector
match = \(TargetStringFileStatus1 [Char]
str1 FileStatus
fstatus1) ->
Match1
f [Char]
str1 FileStatus
fstatus1
syntaxForm2 :: (TargetSelector -> [TargetStringFileStatus]) -> Match2 -> Syntax
syntaxForm2 TargetSelector -> [TargetStringFileStatus]
render Match2
f =
QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> Syntax
Syntax QualLevel
QL2 TargetStringFileStatus -> Match TargetSelector
match TargetSelector -> [TargetStringFileStatus]
render
where
match :: TargetStringFileStatus -> Match TargetSelector
match = \(TargetStringFileStatus2 [Char]
str1 FileStatus
fstatus1 [Char]
str2) ->
Match2
f [Char]
str1 FileStatus
fstatus1 [Char]
str2
syntaxForm3 :: (TargetSelector -> [TargetStringFileStatus]) -> Match3 -> Syntax
syntaxForm3 TargetSelector -> [TargetStringFileStatus]
render Match3
f =
QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> Syntax
Syntax QualLevel
QL3 TargetStringFileStatus -> Match TargetSelector
match TargetSelector -> [TargetStringFileStatus]
render
where
match :: TargetStringFileStatus -> Match TargetSelector
match = \(TargetStringFileStatus3 [Char]
str1 FileStatus
fstatus1 [Char]
str2 [Char]
str3) ->
Match3
f [Char]
str1 FileStatus
fstatus1 [Char]
str2 [Char]
str3
syntaxForm4 :: (TargetSelector -> [TargetStringFileStatus]) -> Match4 -> Syntax
syntaxForm4 TargetSelector -> [TargetStringFileStatus]
render Match4
f =
QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> Syntax
Syntax QualLevel
QLFull TargetStringFileStatus -> Match TargetSelector
match TargetSelector -> [TargetStringFileStatus]
render
where
match :: TargetStringFileStatus -> Match TargetSelector
match (TargetStringFileStatus4 [Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4) =
Match4
f [Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4
match TargetStringFileStatus
_ = Match TargetSelector
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
syntaxForm5 :: (TargetSelector -> [TargetStringFileStatus]) -> Match5 -> Syntax
syntaxForm5 TargetSelector -> [TargetStringFileStatus]
render Match5
f =
QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> Syntax
Syntax QualLevel
QLFull TargetStringFileStatus -> Match TargetSelector
match TargetSelector -> [TargetStringFileStatus]
render
where
match :: TargetStringFileStatus -> Match TargetSelector
match (TargetStringFileStatus5 [Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4 [Char]
str5) =
Match5
f [Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4 [Char]
str5
match TargetStringFileStatus
_ = Match TargetSelector
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
syntaxForm7 :: (TargetSelector -> [TargetStringFileStatus]) -> Match7 -> Syntax
syntaxForm7 TargetSelector -> [TargetStringFileStatus]
render Match7
f =
QualLevel
-> (TargetStringFileStatus -> Match TargetSelector)
-> (TargetSelector -> [TargetStringFileStatus])
-> Syntax
Syntax QualLevel
QLFull TargetStringFileStatus -> Match TargetSelector
match TargetSelector -> [TargetStringFileStatus]
render
where
match :: TargetStringFileStatus -> Match TargetSelector
match (TargetStringFileStatus7 [Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4 [Char]
str5 [Char]
str6 [Char]
str7) =
Match7
f [Char]
str1 [Char]
str2 [Char]
str3 [Char]
str4 [Char]
str5 [Char]
str6 [Char]
str7
match TargetStringFileStatus
_ = Match TargetSelector
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
dispP :: Package p => p -> String
dispP :: forall p. Package p => p -> [Char]
dispP = PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageName -> [Char]) -> (p -> PackageName) -> p -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName
dispPN :: PackageName -> String
dispPN :: PackageName -> [Char]
dispPN = PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow
dispC :: PackageId -> ComponentName -> String
dispC :: PackageIdentifier -> ComponentName -> [Char]
dispC = PackageName -> ComponentName -> [Char]
componentStringName (PackageName -> ComponentName -> [Char])
-> (PackageIdentifier -> PackageName)
-> PackageIdentifier
-> ComponentName
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName
dispC' :: PackageName -> ComponentName -> String
dispC' :: PackageName -> ComponentName -> [Char]
dispC' = PackageName -> ComponentName -> [Char]
componentStringName
dispCN :: UnqualComponentName -> String
dispCN :: UnqualComponentName -> [Char]
dispCN = UnqualComponentName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow
dispK :: ComponentKind -> String
dispK :: ComponentKind -> [Char]
dispK = ComponentKind -> [Char]
showComponentKindShort
dispCK :: ComponentName -> String
dispCK :: ComponentName -> [Char]
dispCK = ComponentKind -> [Char]
dispK (ComponentKind -> [Char])
-> (ComponentName -> ComponentKind) -> ComponentName -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ComponentName -> ComponentKind
componentKind
dispF :: ComponentKind -> String
dispF :: ComponentKind -> [Char]
dispF = ComponentKind -> [Char]
showComponentKindFilterShort
dispM :: ModuleName -> String
dispM :: ModuleName -> [Char]
dispM = ModuleName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow
data KnownTargets = KnownTargets
{ KnownTargets -> [KnownPackage]
knownPackagesAll :: [KnownPackage]
, KnownTargets -> [KnownPackage]
knownPackagesPrimary :: [KnownPackage]
, KnownTargets -> [KnownPackage]
knownPackagesOther :: [KnownPackage]
, KnownTargets -> [KnownComponent]
knownComponentsAll :: [KnownComponent]
, KnownTargets -> [KnownComponent]
knownComponentsPrimary :: [KnownComponent]
, KnownTargets -> [KnownComponent]
knownComponentsOther :: [KnownComponent]
}
deriving (Int -> KnownTargets -> ShowS
[KnownTargets] -> ShowS
KnownTargets -> [Char]
(Int -> KnownTargets -> ShowS)
-> (KnownTargets -> [Char])
-> ([KnownTargets] -> ShowS)
-> Show KnownTargets
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KnownTargets -> ShowS
showsPrec :: Int -> KnownTargets -> ShowS
$cshow :: KnownTargets -> [Char]
show :: KnownTargets -> [Char]
$cshowList :: [KnownTargets] -> ShowS
showList :: [KnownTargets] -> ShowS
Show)
data KnownPackage
= KnownPackage
{ KnownPackage -> PackageIdentifier
pinfoId :: PackageId
, KnownPackage -> Maybe ([Char], [Char])
pinfoDirectory :: Maybe (FilePath, FilePath)
, KnownPackage -> Maybe ([Char], [Char])
pinfoPackageFile :: Maybe (FilePath, FilePath)
, KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
}
| KnownPackageName
{ KnownPackage -> PackageName
pinfoName :: PackageName
}
deriving (Int -> KnownPackage -> ShowS
[KnownPackage] -> ShowS
KnownPackage -> [Char]
(Int -> KnownPackage -> ShowS)
-> (KnownPackage -> [Char])
-> ([KnownPackage] -> ShowS)
-> Show KnownPackage
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KnownPackage -> ShowS
showsPrec :: Int -> KnownPackage -> ShowS
$cshow :: KnownPackage -> [Char]
show :: KnownPackage -> [Char]
$cshowList :: [KnownPackage] -> ShowS
showList :: [KnownPackage] -> ShowS
Show)
data KnownComponent = KnownComponent
{ KnownComponent -> ComponentName
cinfoName :: ComponentName
, KnownComponent -> [Char]
cinfoStrName :: ComponentStringName
, KnownComponent -> PackageIdentifier
cinfoPackageId :: PackageId
, KnownComponent -> [[Char]]
cinfoSrcDirs :: [FilePath]
, KnownComponent -> [ModuleName]
cinfoModules :: [ModuleName]
, KnownComponent -> [[Char]]
cinfoHsFiles :: [FilePath]
, KnownComponent -> [[Char]]
cinfoCFiles :: [FilePath]
, KnownComponent -> [[Char]]
cinfoJsFiles :: [FilePath]
}
deriving (Int -> KnownComponent -> ShowS
[KnownComponent] -> ShowS
KnownComponent -> [Char]
(Int -> KnownComponent -> ShowS)
-> (KnownComponent -> [Char])
-> ([KnownComponent] -> ShowS)
-> Show KnownComponent
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KnownComponent -> ShowS
showsPrec :: Int -> KnownComponent -> ShowS
$cshow :: KnownComponent -> [Char]
show :: KnownComponent -> [Char]
$cshowList :: [KnownComponent] -> ShowS
showList :: [KnownComponent] -> ShowS
Show)
type ComponentStringName = String
knownPackageName :: KnownPackage -> PackageName
knownPackageName :: KnownPackage -> PackageName
knownPackageName KnownPackage{PackageIdentifier
pinfoId :: KnownPackage -> PackageIdentifier
pinfoId :: PackageIdentifier
pinfoId} = PackageIdentifier -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageIdentifier
pinfoId
knownPackageName KnownPackageName{PackageName
pinfoName :: KnownPackage -> PackageName
pinfoName :: PackageName
pinfoName} = PackageName
pinfoName
emptyKnownTargets :: KnownTargets
emptyKnownTargets :: KnownTargets
emptyKnownTargets = [KnownPackage]
-> [KnownPackage]
-> [KnownPackage]
-> [KnownComponent]
-> [KnownComponent]
-> [KnownComponent]
-> KnownTargets
KnownTargets [] [] [] [] [] []
getKnownTargets
:: forall m a
. (Applicative m, Monad m)
=> DirActions m
-> [PackageSpecifier (SourcePackage (PackageLocation a))]
-> m KnownTargets
getKnownTargets :: forall (m :: * -> *) a.
(Applicative m, Monad m) =>
DirActions m
-> [PackageSpecifier (SourcePackage (PackageLocation a))]
-> m KnownTargets
getKnownTargets dirActions :: DirActions m
dirActions@DirActions{m [Char]
[Char] -> m Bool
[Char] -> m [Char]
doesFileExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
doesDirectoryExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
canonicalizePath :: forall (m :: * -> *). DirActions m -> [Char] -> m [Char]
getCurrentDirectory :: forall (m :: * -> *). DirActions m -> m [Char]
doesFileExist :: [Char] -> m Bool
doesDirectoryExist :: [Char] -> m Bool
canonicalizePath :: [Char] -> m [Char]
getCurrentDirectory :: m [Char]
..} [PackageSpecifier (SourcePackage (PackageLocation a))]
pkgs = do
pinfo <- (PackageSpecifier (SourcePackage (PackageLocation a))
-> m KnownPackage)
-> [PackageSpecifier (SourcePackage (PackageLocation a))]
-> m [KnownPackage]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (DirActions m
-> PackageSpecifier (SourcePackage (PackageLocation a))
-> m KnownPackage
forall (m :: * -> *) a.
(Applicative m, Monad m) =>
DirActions m
-> PackageSpecifier (SourcePackage (PackageLocation a))
-> m KnownPackage
collectKnownPackageInfo DirActions m
dirActions) [PackageSpecifier (SourcePackage (PackageLocation a))]
pkgs
cwd <- getCurrentDirectory
(ppinfo, opinfo) <- selectPrimaryPackage cwd pinfo
return
KnownTargets
{ knownPackagesAll = pinfo
, knownPackagesPrimary = ppinfo
, knownPackagesOther = opinfo
, knownComponentsAll = allComponentsIn pinfo
, knownComponentsPrimary = allComponentsIn ppinfo
, knownComponentsOther = allComponentsIn opinfo
}
where
mPkgDir :: KnownPackage -> Maybe FilePath
mPkgDir :: KnownPackage -> Maybe [Char]
mPkgDir KnownPackage{pinfoDirectory :: KnownPackage -> Maybe ([Char], [Char])
pinfoDirectory = Just ([Char]
dir, [Char]
_)} = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
dir
mPkgDir KnownPackage
_ = Maybe [Char]
forall a. Maybe a
Nothing
selectPrimaryPackage
:: FilePath
-> [KnownPackage]
-> m ([KnownPackage], [KnownPackage])
selectPrimaryPackage :: [Char] -> [KnownPackage] -> m ([KnownPackage], [KnownPackage])
selectPrimaryPackage [Char]
_ [] = ([KnownPackage], [KnownPackage])
-> m ([KnownPackage], [KnownPackage])
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([], [])
selectPrimaryPackage [Char]
cwd (KnownPackage
pkg : [KnownPackage]
packages) = do
(ppinfo, opinfo) <- [Char] -> [KnownPackage] -> m ([KnownPackage], [KnownPackage])
selectPrimaryPackage [Char]
cwd [KnownPackage]
packages
isPkgDirCwd <- maybe (pure False) (compareFilePath dirActions cwd) (mPkgDir pkg)
return (if isPkgDirCwd then (pkg : ppinfo, opinfo) else (ppinfo, pkg : opinfo))
allComponentsIn :: [KnownPackage] -> [KnownComponent]
allComponentsIn [KnownPackage]
ps =
[KnownComponent
c | KnownPackage{[KnownComponent]
pinfoComponents :: KnownPackage -> [KnownComponent]
pinfoComponents :: [KnownComponent]
pinfoComponents} <- [KnownPackage]
ps, KnownComponent
c <- [KnownComponent]
pinfoComponents]
collectKnownPackageInfo
:: (Applicative m, Monad m)
=> DirActions m
-> PackageSpecifier (SourcePackage (PackageLocation a))
-> m KnownPackage
collectKnownPackageInfo :: forall (m :: * -> *) a.
(Applicative m, Monad m) =>
DirActions m
-> PackageSpecifier (SourcePackage (PackageLocation a))
-> m KnownPackage
collectKnownPackageInfo DirActions m
_ (NamedPackage PackageName
pkgname [PackageProperty]
_props) =
KnownPackage -> m KnownPackage
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageName -> KnownPackage
KnownPackageName PackageName
pkgname)
collectKnownPackageInfo
dirActions :: DirActions m
dirActions@DirActions{m [Char]
[Char] -> m Bool
[Char] -> m [Char]
doesFileExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
doesDirectoryExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
canonicalizePath :: forall (m :: * -> *). DirActions m -> [Char] -> m [Char]
getCurrentDirectory :: forall (m :: * -> *). DirActions m -> m [Char]
doesFileExist :: [Char] -> m Bool
doesDirectoryExist :: [Char] -> m Bool
canonicalizePath :: [Char] -> m [Char]
getCurrentDirectory :: m [Char]
..}
( SpecificSourcePackage
SourcePackage
{ srcpkgDescription :: forall loc. SourcePackage loc -> GenericPackageDescription
srcpkgDescription = GenericPackageDescription
pkg
, srcpkgSource :: forall loc. SourcePackage loc -> loc
srcpkgSource = PackageLocation a
loc
}
) = do
(pkgdir, pkgfile) <-
case PackageLocation a
loc of
LocalUnpackedPackage [Char]
dir -> do
dirabs <- [Char] -> m [Char]
canonicalizePath [Char]
dir
dirrel <- makeRelativeToCwd dirActions dirabs
let fileabs = [Char]
dirabs [Char] -> ShowS
FilePath.</> PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (GenericPackageDescription -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName GenericPackageDescription
pkg) [Char] -> ShowS
FilePath.<.> [Char]
"cabal"
filerel = [Char]
dirrel [Char] -> ShowS
FilePath.</> PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (GenericPackageDescription -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName GenericPackageDescription
pkg) [Char] -> ShowS
FilePath.<.> [Char]
"cabal"
exists <- doesFileExist fileabs
return
( Just (dirabs, dirrel)
, if exists then Just (fileabs, filerel) else Nothing
)
PackageLocation a
_ -> (Maybe ([Char], [Char]), Maybe ([Char], [Char]))
-> m (Maybe ([Char], [Char]), Maybe ([Char], [Char]))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe ([Char], [Char])
forall a. Maybe a
Nothing, Maybe ([Char], [Char])
forall a. Maybe a
Nothing)
let pinfo =
KnownPackage
{ pinfoId :: PackageIdentifier
pinfoId = GenericPackageDescription -> PackageIdentifier
forall pkg. Package pkg => pkg -> PackageIdentifier
packageId GenericPackageDescription
pkg
, pinfoDirectory :: Maybe ([Char], [Char])
pinfoDirectory = Maybe ([Char], [Char])
pkgdir
, pinfoPackageFile :: Maybe ([Char], [Char])
pinfoPackageFile = Maybe ([Char], [Char])
pkgfile
, pinfoComponents :: [KnownComponent]
pinfoComponents =
PackageDescription -> [KnownComponent]
collectKnownComponentInfo
(GenericPackageDescription -> PackageDescription
flattenPackageDescription GenericPackageDescription
pkg)
}
return pinfo
collectKnownComponentInfo :: PackageDescription -> [KnownComponent]
collectKnownComponentInfo :: PackageDescription -> [KnownComponent]
collectKnownComponentInfo PackageDescription
pkg =
[ KnownComponent
{ cinfoName :: ComponentName
cinfoName = Component -> ComponentName
componentName Component
c
, cinfoStrName :: [Char]
cinfoStrName = PackageName -> ComponentName -> [Char]
componentStringName (PackageDescription -> PackageName
forall pkg. Package pkg => pkg -> PackageName
packageName PackageDescription
pkg) (Component -> ComponentName
componentName Component
c)
, cinfoPackageId :: PackageIdentifier
cinfoPackageId = PackageDescription -> PackageIdentifier
forall pkg. Package pkg => pkg -> PackageIdentifier
packageId PackageDescription
pkg
, cinfoSrcDirs :: [[Char]]
cinfoSrcDirs = [[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
ordNub ((SymbolicPathX 'AllowAbsolute Pkg ('Dir Source) -> [Char])
-> [SymbolicPathX 'AllowAbsolute Pkg ('Dir Source)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map SymbolicPathX 'AllowAbsolute Pkg ('Dir Source) -> [Char]
forall (allowAbsolute :: AllowAbsolute) from (to :: FileOrDir).
SymbolicPathX allowAbsolute from to -> [Char]
getSymbolicPath (BuildInfo -> [SymbolicPathX 'AllowAbsolute Pkg ('Dir Source)]
hsSourceDirs BuildInfo
bi))
, cinfoModules :: [ModuleName]
cinfoModules = [ModuleName] -> [ModuleName]
forall a. Ord a => [a] -> [a]
ordNub (Component -> [ModuleName]
componentModules Component
c)
, cinfoHsFiles :: [[Char]]
cinfoHsFiles = [[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
ordNub (Component -> [[Char]]
componentHsFiles Component
c)
, cinfoCFiles :: [[Char]]
cinfoCFiles = [[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
ordNub ((SymbolicPath Pkg 'File -> [Char])
-> [SymbolicPath Pkg 'File] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map SymbolicPath Pkg 'File -> [Char]
forall (allowAbsolute :: AllowAbsolute) from (to :: FileOrDir).
SymbolicPathX allowAbsolute from to -> [Char]
getSymbolicPath ([SymbolicPath Pkg 'File] -> [[Char]])
-> [SymbolicPath Pkg 'File] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ BuildInfo -> [SymbolicPath Pkg 'File]
cSources BuildInfo
bi)
, cinfoJsFiles :: [[Char]]
cinfoJsFiles = [[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
ordNub ((SymbolicPath Pkg 'File -> [Char])
-> [SymbolicPath Pkg 'File] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map SymbolicPath Pkg 'File -> [Char]
forall (allowAbsolute :: AllowAbsolute) from (to :: FileOrDir).
SymbolicPathX allowAbsolute from to -> [Char]
getSymbolicPath ([SymbolicPath Pkg 'File] -> [[Char]])
-> [SymbolicPath Pkg 'File] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ BuildInfo -> [SymbolicPath Pkg 'File]
jsSources BuildInfo
bi)
}
| Component
c <- PackageDescription -> [Component]
pkgComponents PackageDescription
pkg
, let bi :: BuildInfo
bi = Component -> BuildInfo
componentBuildInfo Component
c
]
componentStringName :: PackageName -> ComponentName -> ComponentStringName
componentStringName :: PackageName -> ComponentName -> [Char]
componentStringName PackageName
pkgname (CLibName LibraryName
LMainLibName) = PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow PackageName
pkgname
componentStringName PackageName
_ (CLibName (LSubLibName UnqualComponentName
name)) = UnqualComponentName -> [Char]
unUnqualComponentName UnqualComponentName
name
componentStringName PackageName
_ (CFLibName UnqualComponentName
name) = UnqualComponentName -> [Char]
unUnqualComponentName UnqualComponentName
name
componentStringName PackageName
_ (CExeName UnqualComponentName
name) = UnqualComponentName -> [Char]
unUnqualComponentName UnqualComponentName
name
componentStringName PackageName
_ (CTestName UnqualComponentName
name) = UnqualComponentName -> [Char]
unUnqualComponentName UnqualComponentName
name
componentStringName PackageName
_ (CBenchName UnqualComponentName
name) = UnqualComponentName -> [Char]
unUnqualComponentName UnqualComponentName
name
componentModules :: Component -> [ModuleName]
componentModules :: Component -> [ModuleName]
componentModules (CLib Library
lib) = Library -> [ModuleName]
explicitLibModules Library
lib
componentModules (CFLib ForeignLib
flib) = ForeignLib -> [ModuleName]
foreignLibModules ForeignLib
flib
componentModules (CExe Executable
exe) = Executable -> [ModuleName]
exeModules Executable
exe
componentModules (CTest TestSuite
test) = TestSuite -> [ModuleName]
testModules TestSuite
test
componentModules (CBench Benchmark
bench) = Benchmark -> [ModuleName]
benchmarkModules Benchmark
bench
componentHsFiles :: Component -> [FilePath]
componentHsFiles :: Component -> [[Char]]
componentHsFiles (CExe Executable
exe) = [SymbolicPathX 'OnlyRelative Source 'File -> [Char]
forall (allowAbsolute :: AllowAbsolute) from (to :: FileOrDir).
SymbolicPathX allowAbsolute from to -> [Char]
getSymbolicPath (SymbolicPathX 'OnlyRelative Source 'File -> [Char])
-> SymbolicPathX 'OnlyRelative Source 'File -> [Char]
forall a b. (a -> b) -> a -> b
$ Executable -> SymbolicPathX 'OnlyRelative Source 'File
modulePath Executable
exe]
componentHsFiles
( CTest
TestSuite
{ testInterface :: TestSuite -> TestSuiteInterface
testInterface = TestSuiteExeV10 Version
_ SymbolicPathX 'OnlyRelative Source 'File
mainfile
}
) = [SymbolicPathX 'OnlyRelative Source 'File -> [Char]
forall (allowAbsolute :: AllowAbsolute) from (to :: FileOrDir).
SymbolicPathX allowAbsolute from to -> [Char]
getSymbolicPath SymbolicPathX 'OnlyRelative Source 'File
mainfile]
componentHsFiles
( CBench
Benchmark
{ benchmarkInterface :: Benchmark -> BenchmarkInterface
benchmarkInterface = BenchmarkExeV10 Version
_ SymbolicPathX 'OnlyRelative Source 'File
mainfile
}
) = [SymbolicPathX 'OnlyRelative Source 'File -> [Char]
forall (allowAbsolute :: AllowAbsolute) from (to :: FileOrDir).
SymbolicPathX allowAbsolute from to -> [Char]
getSymbolicPath SymbolicPathX 'OnlyRelative Source 'File
mainfile]
componentHsFiles Component
_ = []
guardNamespaceMeta :: String -> Match ()
guardNamespaceMeta :: [Char] -> Match ()
guardNamespaceMeta = [[Char]] -> [Char] -> [Char] -> Match ()
guardToken [[Char]
""] [Char]
"meta namespace"
guardMetaAll :: String -> Match ()
guardMetaAll :: [Char] -> Match ()
guardMetaAll = [[Char]] -> [Char] -> [Char] -> Match ()
guardToken [[Char]
"all"] [Char]
"meta-target 'all'"
guardNamespacePackage :: String -> Match ()
guardNamespacePackage :: [Char] -> Match ()
guardNamespacePackage = [[Char]] -> [Char] -> [Char] -> Match ()
guardToken [[Char]
"pkg", [Char]
"package"] [Char]
"'pkg' namespace"
guardNamespaceCwd :: String -> Match ()
guardNamespaceCwd :: [Char] -> Match ()
guardNamespaceCwd = [[Char]] -> [Char] -> [Char] -> Match ()
guardToken [[Char]
"cwd"] [Char]
"'cwd' namespace"
guardNamespaceModule :: String -> Match ()
guardNamespaceModule :: [Char] -> Match ()
guardNamespaceModule = [[Char]] -> [Char] -> [Char] -> Match ()
guardToken [[Char]
"mod", [Char]
"module"] [Char]
"'module' namespace"
guardNamespaceFile :: String -> Match ()
guardNamespaceFile :: [Char] -> Match ()
guardNamespaceFile = [[Char]] -> [Char] -> [Char] -> Match ()
guardToken [[Char]
"file"] [Char]
"'file' namespace"
guardToken :: [String] -> String -> String -> Match ()
guardToken :: [[Char]] -> [Char] -> [Char] -> Match ()
guardToken [[Char]]
tokens [Char]
msg [Char]
s
| ShowS
caseFold [Char]
s [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
tokens = Match ()
increaseConfidence
| Bool
otherwise = [Char] -> [Char] -> Match ()
forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
msg [Char]
s
componentKind :: ComponentName -> ComponentKind
componentKind :: ComponentName -> ComponentKind
componentKind (CLibName LibraryName
_) = ComponentKind
LibKind
componentKind (CFLibName UnqualComponentName
_) = ComponentKind
FLibKind
componentKind (CExeName UnqualComponentName
_) = ComponentKind
ExeKind
componentKind (CTestName UnqualComponentName
_) = ComponentKind
TestKind
componentKind (CBenchName UnqualComponentName
_) = ComponentKind
BenchKind
cinfoKind :: KnownComponent -> ComponentKind
cinfoKind :: KnownComponent -> ComponentKind
cinfoKind = ComponentName -> ComponentKind
componentKind (ComponentName -> ComponentKind)
-> (KnownComponent -> ComponentName)
-> KnownComponent
-> ComponentKind
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KnownComponent -> ComponentName
cinfoName
matchComponentKind :: String -> Match ComponentKind
matchComponentKind :: [Char] -> Match ComponentKind
matchComponentKind [Char]
s
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
liblabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
LibKind
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
fliblabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
FLibKind
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
exelabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
ExeKind
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
testlabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
TestKind
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
benchlabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
BenchKind
| Bool
otherwise = [Char] -> [Char] -> Match ComponentKind
forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
"component kind" [Char]
s
where
s' :: [Char]
s' = ShowS
caseFold [Char]
s
liblabels :: [[Char]]
liblabels = [[Char]
"lib", [Char]
"library"]
fliblabels :: [[Char]]
fliblabels = [[Char]
"flib", [Char]
"foreign-library"]
exelabels :: [[Char]]
exelabels = [[Char]
"exe", [Char]
"executable"]
testlabels :: [[Char]]
testlabels = [[Char]
"tst", [Char]
"test", [Char]
"test-suite"]
benchlabels :: [[Char]]
benchlabels = [[Char]
"bench", [Char]
"benchmark"]
matchComponentKindFilter :: String -> Match ComponentKind
matchComponentKindFilter :: [Char] -> Match ComponentKind
matchComponentKindFilter [Char]
s
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
liblabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
LibKind
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
fliblabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
FLibKind
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
exelabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
ExeKind
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
testlabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
TestKind
| [Char]
s' [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
benchlabels = Match ()
increaseConfidence Match () -> Match ComponentKind -> Match ComponentKind
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ComponentKind -> Match ComponentKind
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ComponentKind
BenchKind
| Bool
otherwise = [Char] -> [Char] -> Match ComponentKind
forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
"component kind filter" [Char]
s
where
s' :: [Char]
s' = ShowS
caseFold [Char]
s
liblabels :: [[Char]]
liblabels = [[Char]
"libs", [Char]
"libraries"]
fliblabels :: [[Char]]
fliblabels = [[Char]
"flibs", [Char]
"foreign-libraries"]
exelabels :: [[Char]]
exelabels = [[Char]
"exes", [Char]
"executables"]
testlabels :: [[Char]]
testlabels = [[Char]
"tests", [Char]
"test-suites"]
benchlabels :: [[Char]]
benchlabels = [[Char]
"benches", [Char]
"benchmarks"]
showComponentKind :: ComponentKind -> String
showComponentKind :: ComponentKind -> [Char]
showComponentKind ComponentKind
LibKind = [Char]
"library"
showComponentKind ComponentKind
FLibKind = [Char]
"foreign library"
showComponentKind ComponentKind
ExeKind = [Char]
"executable"
showComponentKind ComponentKind
TestKind = [Char]
"test-suite"
showComponentKind ComponentKind
BenchKind = [Char]
"benchmark"
showComponentKindShort :: ComponentKind -> String
showComponentKindShort :: ComponentKind -> [Char]
showComponentKindShort ComponentKind
LibKind = [Char]
"lib"
showComponentKindShort ComponentKind
FLibKind = [Char]
"flib"
showComponentKindShort ComponentKind
ExeKind = [Char]
"exe"
showComponentKindShort ComponentKind
TestKind = [Char]
"test"
showComponentKindShort ComponentKind
BenchKind = [Char]
"bench"
showComponentKindFilterShort :: ComponentKind -> String
showComponentKindFilterShort :: ComponentKind -> [Char]
showComponentKindFilterShort ComponentKind
LibKind = [Char]
"libs"
showComponentKindFilterShort ComponentKind
FLibKind = [Char]
"flibs"
showComponentKindFilterShort ComponentKind
ExeKind = [Char]
"exes"
showComponentKindFilterShort ComponentKind
TestKind = [Char]
"tests"
showComponentKindFilterShort ComponentKind
BenchKind = [Char]
"benchmarks"
guardPackage :: String -> FileStatus -> Match ()
guardPackage :: [Char] -> FileStatus -> Match ()
guardPackage [Char]
str FileStatus
fstatus =
[Char] -> Match ()
guardPackageName [Char]
str
Match () -> Match () -> Match ()
forall a. Match a -> Match a -> Match a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> FileStatus -> Match ()
guardPackageDir [Char]
str FileStatus
fstatus
Match () -> Match () -> Match ()
forall a. Match a -> Match a -> Match a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> FileStatus -> Match ()
guardPackageFile [Char]
str FileStatus
fstatus
guardPackageName :: String -> Match ()
guardPackageName :: [Char] -> Match ()
guardPackageName [Char]
s
| [Char] -> Bool
validPackageName [Char]
s = Match ()
increaseConfidence
| Bool
otherwise = [Char] -> [Char] -> Match ()
forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
"package name" [Char]
s
validPackageName :: String -> Bool
validPackageName :: [Char] -> Bool
validPackageName [Char]
s =
(Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
validPackageNameChar [Char]
s
Bool -> Bool -> Bool
&& Bool -> Bool
not ([Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
s)
where
validPackageNameChar :: Char -> Bool
validPackageNameChar Char
c = Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'-'
guardPackageDir :: String -> FileStatus -> Match ()
guardPackageDir :: [Char] -> FileStatus -> Match ()
guardPackageDir [Char]
_ (FileStatusExistsDir [Char]
_) = Match ()
increaseConfidence
guardPackageDir [Char]
str FileStatus
_ = [Char] -> [Char] -> Match ()
forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
"package directory" [Char]
str
guardPackageFile :: String -> FileStatus -> Match ()
guardPackageFile :: [Char] -> FileStatus -> Match ()
guardPackageFile [Char]
_ (FileStatusExistsFile [Char]
file)
| ShowS
FilePath.takeExtension [Char]
file [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
".cabal" =
Match ()
increaseConfidence
guardPackageFile [Char]
str FileStatus
_ = [Char] -> [Char] -> Match ()
forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
"package .cabal file" [Char]
str
matchPackage :: [KnownPackage] -> String -> FileStatus -> Match KnownPackage
matchPackage :: [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackage [KnownPackage]
pinfo = \[Char]
str FileStatus
fstatus ->
[Char] -> [Char] -> Match KnownPackage -> Match KnownPackage
forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
"project" [Char]
"" (Match KnownPackage -> Match KnownPackage)
-> Match KnownPackage -> Match KnownPackage
forall a b. (a -> b) -> a -> b
$
[KnownPackage] -> [Char] -> Match KnownPackage
matchPackageName [KnownPackage]
pinfo [Char]
str
Match KnownPackage -> Match KnownPackage -> Match KnownPackage
forall a. Match a -> Match a -> Match a
</> ( [Char] -> Match KnownPackage
matchPackageNameUnknown [Char]
str
Match KnownPackage -> Match KnownPackage -> Match KnownPackage
forall a. Match a -> Match a -> Match a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackageDir [KnownPackage]
pinfo [Char]
str FileStatus
fstatus
Match KnownPackage -> Match KnownPackage -> Match KnownPackage
forall a. Match a -> Match a -> Match a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackageFile [KnownPackage]
pinfo [Char]
str FileStatus
fstatus
)
matchPackageName :: [KnownPackage] -> String -> Match KnownPackage
matchPackageName :: [KnownPackage] -> [Char] -> Match KnownPackage
matchPackageName [KnownPackage]
ps = \[Char]
str -> do
Bool -> Match ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard ([Char] -> Bool
validPackageName [Char]
str)
[Char]
-> [Char] -> [[Char]] -> Match KnownPackage -> Match KnownPackage
forall a. [Char] -> [Char] -> [[Char]] -> Match a -> Match a
orNoSuchThing
[Char]
"package"
[Char]
str
((KnownPackage -> [Char]) -> [KnownPackage] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageName -> [Char])
-> (KnownPackage -> PackageName) -> KnownPackage -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KnownPackage -> PackageName
knownPackageName) [KnownPackage]
ps)
(Match KnownPackage -> Match KnownPackage)
-> Match KnownPackage -> Match KnownPackage
forall a b. (a -> b) -> a -> b
$ Match KnownPackage -> Match KnownPackage
forall a. Match a -> Match a
increaseConfidenceFor
(Match KnownPackage -> Match KnownPackage)
-> Match KnownPackage -> Match KnownPackage
forall a b. (a -> b) -> a -> b
$ ShowS
-> (KnownPackage -> [Char])
-> [KnownPackage]
-> [Char]
-> Match KnownPackage
forall k k' a.
(Ord k, Ord k') =>
(k -> k') -> (a -> k) -> [a] -> k -> Match a
matchInexactly ShowS
caseFold (PackageName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (PackageName -> [Char])
-> (KnownPackage -> PackageName) -> KnownPackage -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. KnownPackage -> PackageName
knownPackageName) [KnownPackage]
ps [Char]
str
matchPackageNameUnknown :: String -> Match KnownPackage
matchPackageNameUnknown :: [Char] -> Match KnownPackage
matchPackageNameUnknown [Char]
str = do
pn <- [Char] -> Match PackageName
forall a. Parsec a => [Char] -> Match a
matchParse [Char]
str
unknownMatch (KnownPackageName pn)
matchPackageDir
:: [KnownPackage]
-> String
-> FileStatus
-> Match KnownPackage
matchPackageDir :: [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackageDir [KnownPackage]
ps = \[Char]
str FileStatus
fstatus ->
case FileStatus
fstatus of
FileStatusExistsDir [Char]
canondir ->
[Char]
-> [Char] -> [[Char]] -> Match KnownPackage -> Match KnownPackage
forall a. [Char] -> [Char] -> [[Char]] -> Match a -> Match a
orNoSuchThing [Char]
"package directory" [Char]
str (((([Char], [Char]), KnownPackage) -> [Char])
-> [(([Char], [Char]), KnownPackage)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (([Char], [Char]) -> [Char]
forall a b. (a, b) -> b
snd (([Char], [Char]) -> [Char])
-> ((([Char], [Char]), KnownPackage) -> ([Char], [Char]))
-> (([Char], [Char]), KnownPackage)
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([Char], [Char]), KnownPackage) -> ([Char], [Char])
forall a b. (a, b) -> a
fst) [(([Char], [Char]), KnownPackage)]
dirs) (Match KnownPackage -> Match KnownPackage)
-> Match KnownPackage -> Match KnownPackage
forall a b. (a -> b) -> a -> b
$
Match KnownPackage -> Match KnownPackage
forall a. Match a -> Match a
increaseConfidenceFor (Match KnownPackage -> Match KnownPackage)
-> Match KnownPackage -> Match KnownPackage
forall a b. (a -> b) -> a -> b
$
((([Char], [Char]), KnownPackage) -> KnownPackage)
-> Match (([Char], [Char]), KnownPackage) -> Match KnownPackage
forall a b. (a -> b) -> Match a -> Match b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([Char], [Char]), KnownPackage) -> KnownPackage
forall a b. (a, b) -> b
snd (Match (([Char], [Char]), KnownPackage) -> Match KnownPackage)
-> Match (([Char], [Char]), KnownPackage) -> Match KnownPackage
forall a b. (a -> b) -> a -> b
$
((([Char], [Char]), KnownPackage) -> [Char])
-> [(([Char], [Char]), KnownPackage)]
-> [Char]
-> Match (([Char], [Char]), KnownPackage)
forall k a. Ord k => (a -> k) -> [a] -> k -> Match a
matchExactly (([Char], [Char]) -> [Char]
forall a b. (a, b) -> a
fst (([Char], [Char]) -> [Char])
-> ((([Char], [Char]), KnownPackage) -> ([Char], [Char]))
-> (([Char], [Char]), KnownPackage)
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([Char], [Char]), KnownPackage) -> ([Char], [Char])
forall a b. (a, b) -> a
fst) [(([Char], [Char]), KnownPackage)]
dirs [Char]
canondir
FileStatus
_ -> Match KnownPackage
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
where
dirs :: [(([Char], [Char]), KnownPackage)]
dirs =
[ (([Char]
dabs, [Char]
drel), KnownPackage
p)
| p :: KnownPackage
p@KnownPackage{pinfoDirectory :: KnownPackage -> Maybe ([Char], [Char])
pinfoDirectory = Just ([Char]
dabs, [Char]
drel)} <- [KnownPackage]
ps
]
matchPackageFile :: [KnownPackage] -> String -> FileStatus -> Match KnownPackage
matchPackageFile :: [KnownPackage] -> [Char] -> FileStatus -> Match KnownPackage
matchPackageFile [KnownPackage]
ps = \[Char]
str FileStatus
fstatus -> do
case FileStatus
fstatus of
FileStatusExistsFile [Char]
canonfile ->
[Char]
-> [Char] -> [[Char]] -> Match KnownPackage -> Match KnownPackage
forall a. [Char] -> [Char] -> [[Char]] -> Match a -> Match a
orNoSuchThing [Char]
"package .cabal file" [Char]
str (((([Char], [Char]), KnownPackage) -> [Char])
-> [(([Char], [Char]), KnownPackage)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (([Char], [Char]) -> [Char]
forall a b. (a, b) -> b
snd (([Char], [Char]) -> [Char])
-> ((([Char], [Char]), KnownPackage) -> ([Char], [Char]))
-> (([Char], [Char]), KnownPackage)
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([Char], [Char]), KnownPackage) -> ([Char], [Char])
forall a b. (a, b) -> a
fst) [(([Char], [Char]), KnownPackage)]
files) (Match KnownPackage -> Match KnownPackage)
-> Match KnownPackage -> Match KnownPackage
forall a b. (a -> b) -> a -> b
$
Match KnownPackage -> Match KnownPackage
forall a. Match a -> Match a
increaseConfidenceFor (Match KnownPackage -> Match KnownPackage)
-> Match KnownPackage -> Match KnownPackage
forall a b. (a -> b) -> a -> b
$
((([Char], [Char]), KnownPackage) -> KnownPackage)
-> Match (([Char], [Char]), KnownPackage) -> Match KnownPackage
forall a b. (a -> b) -> Match a -> Match b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([Char], [Char]), KnownPackage) -> KnownPackage
forall a b. (a, b) -> b
snd (Match (([Char], [Char]), KnownPackage) -> Match KnownPackage)
-> Match (([Char], [Char]), KnownPackage) -> Match KnownPackage
forall a b. (a -> b) -> a -> b
$
((([Char], [Char]), KnownPackage) -> [Char])
-> [(([Char], [Char]), KnownPackage)]
-> [Char]
-> Match (([Char], [Char]), KnownPackage)
forall k a. Ord k => (a -> k) -> [a] -> k -> Match a
matchExactly (([Char], [Char]) -> [Char]
forall a b. (a, b) -> a
fst (([Char], [Char]) -> [Char])
-> ((([Char], [Char]), KnownPackage) -> ([Char], [Char]))
-> (([Char], [Char]), KnownPackage)
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([Char], [Char]), KnownPackage) -> ([Char], [Char])
forall a b. (a, b) -> a
fst) [(([Char], [Char]), KnownPackage)]
files [Char]
canonfile
FileStatus
_ -> Match KnownPackage
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
where
files :: [(([Char], [Char]), KnownPackage)]
files =
[ (([Char]
fabs, [Char]
frel), KnownPackage
p)
| p :: KnownPackage
p@KnownPackage{pinfoPackageFile :: KnownPackage -> Maybe ([Char], [Char])
pinfoPackageFile = Just ([Char]
fabs, [Char]
frel)} <- [KnownPackage]
ps
]
guardComponentName :: String -> Match ()
guardComponentName :: [Char] -> Match ()
guardComponentName [Char]
s
| (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
validComponentChar [Char]
s
Bool -> Bool -> Bool
&& Bool -> Bool
not ([Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
s) =
Match ()
increaseConfidence
| Bool
otherwise = [Char] -> [Char] -> Match ()
forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
"component name" [Char]
s
where
validComponentChar :: Char -> Bool
validComponentChar Char
c =
Char -> Bool
isAlphaNum Char
c
Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.'
Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_'
Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'-'
Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\''
matchComponentName :: [KnownComponent] -> String -> Match KnownComponent
matchComponentName :: [KnownComponent] -> [Char] -> Match KnownComponent
matchComponentName [KnownComponent]
cs [Char]
str =
[Char]
-> [Char]
-> [[Char]]
-> Match KnownComponent
-> Match KnownComponent
forall a. [Char] -> [Char] -> [[Char]] -> Match a -> Match a
orNoSuchThing [Char]
"component" [Char]
str ((KnownComponent -> [Char]) -> [KnownComponent] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map KnownComponent -> [Char]
cinfoStrName [KnownComponent]
cs) (Match KnownComponent -> Match KnownComponent)
-> Match KnownComponent -> Match KnownComponent
forall a b. (a -> b) -> a -> b
$
Match KnownComponent -> Match KnownComponent
forall a. Match a -> Match a
increaseConfidenceFor (Match KnownComponent -> Match KnownComponent)
-> Match KnownComponent -> Match KnownComponent
forall a b. (a -> b) -> a -> b
$
ShowS
-> (KnownComponent -> [Char])
-> [KnownComponent]
-> [Char]
-> Match KnownComponent
forall k k' a.
(Ord k, Ord k') =>
(k -> k') -> (a -> k) -> [a] -> k -> Match a
matchInexactly ShowS
caseFold KnownComponent -> [Char]
cinfoStrName [KnownComponent]
cs [Char]
str
matchComponentKindAndName
:: [KnownComponent]
-> ComponentKind
-> String
-> Match KnownComponent
matchComponentKindAndName :: [KnownComponent] -> ComponentKind -> [Char] -> Match KnownComponent
matchComponentKindAndName [KnownComponent]
cs ComponentKind
ckind [Char]
str =
[Char]
-> [Char]
-> [[Char]]
-> Match KnownComponent
-> Match KnownComponent
forall a. [Char] -> [Char] -> [[Char]] -> Match a -> Match a
orNoSuchThing
(ComponentKind -> [Char]
showComponentKind ComponentKind
ckind [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" component")
[Char]
str
((KnownComponent -> [Char]) -> [KnownComponent] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map KnownComponent -> [Char]
render [KnownComponent]
cs)
(Match KnownComponent -> Match KnownComponent)
-> Match KnownComponent -> Match KnownComponent
forall a b. (a -> b) -> a -> b
$ Match KnownComponent -> Match KnownComponent
forall a. Match a -> Match a
increaseConfidenceFor
(Match KnownComponent -> Match KnownComponent)
-> Match KnownComponent -> Match KnownComponent
forall a b. (a -> b) -> a -> b
$ ((ComponentKind, [Char]) -> (ComponentKind, [Char]))
-> (KnownComponent -> (ComponentKind, [Char]))
-> [KnownComponent]
-> (ComponentKind, [Char])
-> Match KnownComponent
forall k k' a.
(Ord k, Ord k') =>
(k -> k') -> (a -> k) -> [a] -> k -> Match a
matchInexactly
(\(ComponentKind
ck, [Char]
cn) -> (ComponentKind
ck, ShowS
caseFold [Char]
cn))
(\KnownComponent
c -> (KnownComponent -> ComponentKind
cinfoKind KnownComponent
c, KnownComponent -> [Char]
cinfoStrName KnownComponent
c))
[KnownComponent]
cs
(ComponentKind
ckind, [Char]
str)
where
render :: KnownComponent -> [Char]
render KnownComponent
c = ComponentKind -> [Char]
showComponentKindShort (KnownComponent -> ComponentKind
cinfoKind KnownComponent
c) [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
":" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ KnownComponent -> [Char]
cinfoStrName KnownComponent
c
guardModuleName :: String -> Match ()
guardModuleName :: [Char] -> Match ()
guardModuleName [Char]
s =
case [Char] -> Maybe ModuleName
forall a. Parsec a => [Char] -> Maybe a
simpleParsec [Char]
s :: Maybe ModuleName of
Just ModuleName
_ -> Match ()
increaseConfidence
Maybe ModuleName
_
| (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
validModuleChar [Char]
s
Bool -> Bool -> Bool
&& Bool -> Bool
not ([Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
s) ->
() -> Match ()
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
| Bool
otherwise -> [Char] -> [Char] -> Match ()
forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
"module name" [Char]
s
where
validModuleChar :: Char -> Bool
validModuleChar Char
c = Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\''
matchModuleName :: [ModuleName] -> String -> Match ModuleName
matchModuleName :: [ModuleName] -> [Char] -> Match ModuleName
matchModuleName [ModuleName]
ms [Char]
str =
[Char]
-> [Char] -> [[Char]] -> Match ModuleName -> Match ModuleName
forall a. [Char] -> [Char] -> [[Char]] -> Match a -> Match a
orNoSuchThing [Char]
"module" [Char]
str ((ModuleName -> [Char]) -> [ModuleName] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ModuleName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow [ModuleName]
ms) (Match ModuleName -> Match ModuleName)
-> Match ModuleName -> Match ModuleName
forall a b. (a -> b) -> a -> b
$
Match ModuleName -> Match ModuleName
forall a. Match a -> Match a
increaseConfidenceFor (Match ModuleName -> Match ModuleName)
-> Match ModuleName -> Match ModuleName
forall a b. (a -> b) -> a -> b
$
ShowS
-> (ModuleName -> [Char])
-> [ModuleName]
-> [Char]
-> Match ModuleName
forall k k' a.
(Ord k, Ord k') =>
(k -> k') -> (a -> k) -> [a] -> k -> Match a
matchInexactly ShowS
caseFold ModuleName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow [ModuleName]
ms [Char]
str
matchModuleNameAnd :: [(ModuleName, a)] -> String -> Match (ModuleName, a)
matchModuleNameAnd :: forall a. [(ModuleName, a)] -> [Char] -> Match (ModuleName, a)
matchModuleNameAnd [(ModuleName, a)]
ms [Char]
str =
[Char]
-> [Char]
-> [[Char]]
-> Match (ModuleName, a)
-> Match (ModuleName, a)
forall a. [Char] -> [Char] -> [[Char]] -> Match a -> Match a
orNoSuchThing [Char]
"module" [Char]
str (((ModuleName, a) -> [Char]) -> [(ModuleName, a)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map (ModuleName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (ModuleName -> [Char])
-> ((ModuleName, a) -> ModuleName) -> (ModuleName, a) -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModuleName, a) -> ModuleName
forall a b. (a, b) -> a
fst) [(ModuleName, a)]
ms) (Match (ModuleName, a) -> Match (ModuleName, a))
-> Match (ModuleName, a) -> Match (ModuleName, a)
forall a b. (a -> b) -> a -> b
$
Match (ModuleName, a) -> Match (ModuleName, a)
forall a. Match a -> Match a
increaseConfidenceFor (Match (ModuleName, a) -> Match (ModuleName, a))
-> Match (ModuleName, a) -> Match (ModuleName, a)
forall a b. (a -> b) -> a -> b
$
ShowS
-> ((ModuleName, a) -> [Char])
-> [(ModuleName, a)]
-> [Char]
-> Match (ModuleName, a)
forall k k' a.
(Ord k, Ord k') =>
(k -> k') -> (a -> k) -> [a] -> k -> Match a
matchInexactly ShowS
caseFold (ModuleName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow (ModuleName -> [Char])
-> ((ModuleName, a) -> ModuleName) -> (ModuleName, a) -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModuleName, a) -> ModuleName
forall a b. (a, b) -> a
fst) [(ModuleName, a)]
ms [Char]
str
matchModuleNameUnknown :: String -> Match ModuleName
matchModuleNameUnknown :: [Char] -> Match ModuleName
matchModuleNameUnknown [Char]
str =
[Char] -> [Char] -> Match ModuleName -> Match ModuleName
forall a. [Char] -> [Char] -> Match a -> Match a
expecting [Char]
"module" [Char]
str (Match ModuleName -> Match ModuleName)
-> Match ModuleName -> Match ModuleName
forall a b. (a -> b) -> a -> b
$
Match ModuleName -> Match ModuleName
forall a. Match a -> Match a
increaseConfidenceFor (Match ModuleName -> Match ModuleName)
-> Match ModuleName -> Match ModuleName
forall a b. (a -> b) -> a -> b
$
[Char] -> Match ModuleName
forall a. Parsec a => [Char] -> Match a
matchParse [Char]
str
matchPackageDirectoryPrefix
:: [KnownPackage]
-> FileStatus
-> Match (FilePath, KnownPackage)
matchPackageDirectoryPrefix :: [KnownPackage] -> FileStatus -> Match ([Char], KnownPackage)
matchPackageDirectoryPrefix [KnownPackage]
ps (FileStatusExistsFile [Char]
filepath) =
Match ([Char], KnownPackage) -> Match ([Char], KnownPackage)
forall a. Match a -> Match a
increaseConfidenceFor (Match ([Char], KnownPackage) -> Match ([Char], KnownPackage))
-> Match ([Char], KnownPackage) -> Match ([Char], KnownPackage)
forall a b. (a -> b) -> a -> b
$
[([Char], KnownPackage)] -> [Char] -> Match ([Char], KnownPackage)
forall a. [([Char], a)] -> [Char] -> Match ([Char], a)
matchDirectoryPrefix [([Char], KnownPackage)]
pkgdirs [Char]
filepath
where
pkgdirs :: [([Char], KnownPackage)]
pkgdirs =
[ ([Char]
dir, KnownPackage
p)
| p :: KnownPackage
p@KnownPackage{pinfoDirectory :: KnownPackage -> Maybe ([Char], [Char])
pinfoDirectory = Just ([Char]
dir, [Char]
_)} <- [KnownPackage]
ps
]
matchPackageDirectoryPrefix [KnownPackage]
_ FileStatus
_ = Match ([Char], KnownPackage)
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
matchComponentFile
:: [KnownComponent]
-> String
-> Match (FilePath, KnownComponent)
matchComponentFile :: [KnownComponent] -> [Char] -> Match ([Char], KnownComponent)
matchComponentFile [KnownComponent]
cs [Char]
str =
[Char]
-> [Char]
-> [[Char]]
-> Match ([Char], KnownComponent)
-> Match ([Char], KnownComponent)
forall a. [Char] -> [Char] -> [[Char]] -> Match a -> Match a
orNoSuchThing [Char]
"file" [Char]
str [] (Match ([Char], KnownComponent) -> Match ([Char], KnownComponent))
-> Match ([Char], KnownComponent) -> Match ([Char], KnownComponent)
forall a b. (a -> b) -> a -> b
$
[KnownComponent] -> [Char] -> Match ([Char], KnownComponent)
matchComponentModuleFile [KnownComponent]
cs [Char]
str
Match ([Char], KnownComponent)
-> Match ([Char], KnownComponent) -> Match ([Char], KnownComponent)
forall a. Match a -> Match a -> Match a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [KnownComponent] -> [Char] -> Match ([Char], KnownComponent)
matchComponentOtherFile [KnownComponent]
cs [Char]
str
matchComponentOtherFile
:: [KnownComponent]
-> String
-> Match (FilePath, KnownComponent)
matchComponentOtherFile :: [KnownComponent] -> [Char] -> Match ([Char], KnownComponent)
matchComponentOtherFile [KnownComponent]
cs =
[([Char], KnownComponent)]
-> [Char] -> Match ([Char], KnownComponent)
forall a. [([Char], a)] -> [Char] -> Match ([Char], a)
matchFile
[ (ShowS
normalise ([Char]
srcdir [Char] -> ShowS
FilePath.</> [Char]
file), KnownComponent
c)
| KnownComponent
c <- [KnownComponent]
cs
, [Char]
srcdir <- KnownComponent -> [[Char]]
cinfoSrcDirs KnownComponent
c
, [Char]
file <-
KnownComponent -> [[Char]]
cinfoHsFiles KnownComponent
c
[[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ KnownComponent -> [[Char]]
cinfoCFiles KnownComponent
c
[[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ KnownComponent -> [[Char]]
cinfoJsFiles KnownComponent
c
]
([Char] -> Match ([Char], KnownComponent))
-> ShowS -> [Char] -> Match ([Char], KnownComponent)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
normalise
matchComponentModuleFile
:: [KnownComponent]
-> String
-> Match (FilePath, KnownComponent)
matchComponentModuleFile :: [KnownComponent] -> [Char] -> Match ([Char], KnownComponent)
matchComponentModuleFile [KnownComponent]
cs [Char]
str = do
[([Char], KnownComponent)]
-> [Char] -> Match ([Char], KnownComponent)
forall a. [([Char], a)] -> [Char] -> Match ([Char], a)
matchFile
[ (ShowS
normalise ([Char]
d [Char] -> ShowS
FilePath.</> ModuleName -> [Char]
toFilePath ModuleName
m), KnownComponent
c)
| KnownComponent
c <- [KnownComponent]
cs
, [Char]
d <- KnownComponent -> [[Char]]
cinfoSrcDirs KnownComponent
c
, ModuleName
m <- KnownComponent -> [ModuleName]
cinfoModules KnownComponent
c
]
(ShowS
dropExtension (ShowS
normalise [Char]
str))
compareFilePath
:: (Applicative m, Monad m)
=> DirActions m
-> FilePath
-> FilePath
-> m Bool
compareFilePath :: forall (m :: * -> *).
(Applicative m, Monad m) =>
DirActions m -> [Char] -> [Char] -> m Bool
compareFilePath DirActions{m [Char]
[Char] -> m Bool
[Char] -> m [Char]
doesFileExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
doesDirectoryExist :: forall (m :: * -> *). DirActions m -> [Char] -> m Bool
canonicalizePath :: forall (m :: * -> *). DirActions m -> [Char] -> m [Char]
getCurrentDirectory :: forall (m :: * -> *). DirActions m -> m [Char]
doesFileExist :: [Char] -> m Bool
doesDirectoryExist :: [Char] -> m Bool
canonicalizePath :: [Char] -> m [Char]
getCurrentDirectory :: m [Char]
..} [Char]
fp1 [Char]
fp2
| [Char] -> [Char] -> Bool
equalFilePath [Char]
fp1 [Char]
fp2 = Bool -> m Bool
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
| Bool
otherwise = do
c1 <- [Char] -> m [Char]
canonicalizePath [Char]
fp1
c2 <- canonicalizePath fp2
pure $ equalFilePath c1 c2
matchFile :: [(FilePath, a)] -> FilePath -> Match (FilePath, a)
matchFile :: forall a. [([Char], a)] -> [Char] -> Match ([Char], a)
matchFile [([Char], a)]
fs =
Match ([Char], a) -> Match ([Char], a)
forall a. Match a -> Match a
increaseConfidenceFor
(Match ([Char], a) -> Match ([Char], a))
-> ([Char] -> Match ([Char], a)) -> [Char] -> Match ([Char], a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
-> (([Char], a) -> [Char])
-> [([Char], a)]
-> [Char]
-> Match ([Char], a)
forall k k' a.
(Ord k, Ord k') =>
(k -> k') -> (a -> k) -> [a] -> k -> Match a
matchInexactly ShowS
caseFold ([Char], a) -> [Char]
forall a b. (a, b) -> a
fst [([Char], a)]
fs
matchDirectoryPrefix :: [(FilePath, a)] -> FilePath -> Match (FilePath, a)
matchDirectoryPrefix :: forall a. [([Char], a)] -> [Char] -> Match ([Char], a)
matchDirectoryPrefix [([Char], a)]
dirs [Char]
filepath =
[([Char], a)] -> Match ([Char], a)
forall a. [a] -> Match a
tryEach ([([Char], a)] -> Match ([Char], a))
-> [([Char], a)] -> Match ([Char], a)
forall a b. (a -> b) -> a -> b
$
[ ([Char]
file, a
x)
| ([Char]
dir, a
x) <- [([Char], a)]
dirs
, [Char]
file <- Maybe [Char] -> [[Char]]
forall a. Maybe a -> [a]
maybeToList ([Char] -> Maybe [Char]
stripDirectory [Char]
dir)
]
where
stripDirectory :: FilePath -> Maybe FilePath
stripDirectory :: [Char] -> Maybe [Char]
stripDirectory [Char]
dir =
[[Char]] -> [Char]
joinPath ([[Char]] -> [Char]) -> Maybe [[Char]] -> Maybe [Char]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [[Char]] -> [[Char]] -> Maybe [[Char]]
forall a. Eq a => [a] -> [a] -> Maybe [a]
stripPrefix ([Char] -> [[Char]]
splitDirectories [Char]
dir) [[Char]]
filepathsplit
filepathsplit :: [[Char]]
filepathsplit = [Char] -> [[Char]]
splitDirectories [Char]
filepath
data Match a
= NoMatch !Confidence [MatchError]
| Match !MatchClass !Confidence [a]
deriving (Int -> Match a -> ShowS
[Match a] -> ShowS
Match a -> [Char]
(Int -> Match a -> ShowS)
-> (Match a -> [Char]) -> ([Match a] -> ShowS) -> Show (Match a)
forall a. Show a => Int -> Match a -> ShowS
forall a. Show a => [Match a] -> ShowS
forall a. Show a => Match a -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Match a -> ShowS
showsPrec :: Int -> Match a -> ShowS
$cshow :: forall a. Show a => Match a -> [Char]
show :: Match a -> [Char]
$cshowList :: forall a. Show a => [Match a] -> ShowS
showList :: [Match a] -> ShowS
Show)
data MatchClass
=
Unknown
|
Inexact
|
Exact
deriving (Int -> MatchClass -> ShowS
[MatchClass] -> ShowS
MatchClass -> [Char]
(Int -> MatchClass -> ShowS)
-> (MatchClass -> [Char])
-> ([MatchClass] -> ShowS)
-> Show MatchClass
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MatchClass -> ShowS
showsPrec :: Int -> MatchClass -> ShowS
$cshow :: MatchClass -> [Char]
show :: MatchClass -> [Char]
$cshowList :: [MatchClass] -> ShowS
showList :: [MatchClass] -> ShowS
Show, MatchClass -> MatchClass -> Bool
(MatchClass -> MatchClass -> Bool)
-> (MatchClass -> MatchClass -> Bool) -> Eq MatchClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MatchClass -> MatchClass -> Bool
== :: MatchClass -> MatchClass -> Bool
$c/= :: MatchClass -> MatchClass -> Bool
/= :: MatchClass -> MatchClass -> Bool
Eq, Eq MatchClass
Eq MatchClass =>
(MatchClass -> MatchClass -> Ordering)
-> (MatchClass -> MatchClass -> Bool)
-> (MatchClass -> MatchClass -> Bool)
-> (MatchClass -> MatchClass -> Bool)
-> (MatchClass -> MatchClass -> Bool)
-> (MatchClass -> MatchClass -> MatchClass)
-> (MatchClass -> MatchClass -> MatchClass)
-> Ord MatchClass
MatchClass -> MatchClass -> Bool
MatchClass -> MatchClass -> Ordering
MatchClass -> MatchClass -> MatchClass
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MatchClass -> MatchClass -> Ordering
compare :: MatchClass -> MatchClass -> Ordering
$c< :: MatchClass -> MatchClass -> Bool
< :: MatchClass -> MatchClass -> Bool
$c<= :: MatchClass -> MatchClass -> Bool
<= :: MatchClass -> MatchClass -> Bool
$c> :: MatchClass -> MatchClass -> Bool
> :: MatchClass -> MatchClass -> Bool
$c>= :: MatchClass -> MatchClass -> Bool
>= :: MatchClass -> MatchClass -> Bool
$cmax :: MatchClass -> MatchClass -> MatchClass
max :: MatchClass -> MatchClass -> MatchClass
$cmin :: MatchClass -> MatchClass -> MatchClass
min :: MatchClass -> MatchClass -> MatchClass
Ord)
type Confidence = Int
data MatchError
= MatchErrorExpected String String
| MatchErrorNoSuch String String [String]
| MatchErrorIn String String MatchError
deriving (Int -> MatchError -> ShowS
[MatchError] -> ShowS
MatchError -> [Char]
(Int -> MatchError -> ShowS)
-> (MatchError -> [Char])
-> ([MatchError] -> ShowS)
-> Show MatchError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MatchError -> ShowS
showsPrec :: Int -> MatchError -> ShowS
$cshow :: MatchError -> [Char]
show :: MatchError -> [Char]
$cshowList :: [MatchError] -> ShowS
showList :: [MatchError] -> ShowS
Show, MatchError -> MatchError -> Bool
(MatchError -> MatchError -> Bool)
-> (MatchError -> MatchError -> Bool) -> Eq MatchError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MatchError -> MatchError -> Bool
== :: MatchError -> MatchError -> Bool
$c/= :: MatchError -> MatchError -> Bool
/= :: MatchError -> MatchError -> Bool
Eq)
instance Functor Match where
fmap :: forall a b. (a -> b) -> Match a -> Match b
fmap a -> b
_ (NoMatch Int
d [MatchError]
ms) = Int -> [MatchError] -> Match b
forall a. Int -> [MatchError] -> Match a
NoMatch Int
d [MatchError]
ms
fmap a -> b
f (Match MatchClass
m Int
d [a]
xs) = MatchClass -> Int -> [b] -> Match b
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
m Int
d ((a -> b) -> [a] -> [b]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f [a]
xs)
instance Applicative Match where
pure :: forall a. a -> Match a
pure a
a = MatchClass -> Int -> [a] -> Match a
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
Exact Int
0 [a
a]
<*> :: forall a b. Match (a -> b) -> Match a -> Match b
(<*>) = Match (a -> b) -> Match a -> Match b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap
instance Alternative Match where
empty :: forall a. Match a
empty = Int -> [MatchError] -> Match a
forall a. Int -> [MatchError] -> Match a
NoMatch Int
0 []
<|> :: forall a. Match a -> Match a -> Match a
(<|>) = Match a -> Match a -> Match a
forall a. Match a -> Match a -> Match a
matchPlus
instance Monad Match where
return :: forall a. a -> Match a
return = a -> Match a
forall a. a -> Match a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
NoMatch Int
d [MatchError]
ms >>= :: forall a b. Match a -> (a -> Match b) -> Match b
>>= a -> Match b
_ = Int -> [MatchError] -> Match b
forall a. Int -> [MatchError] -> Match a
NoMatch Int
d [MatchError]
ms
Match MatchClass
m Int
d [a]
xs >>= a -> Match b
f =
case [Match b] -> Match b
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum ((a -> Match b) -> [a] -> [Match b]
forall a b. (a -> b) -> [a] -> [b]
map a -> Match b
f [a]
xs) of
Match MatchClass
m' Int
d' [b]
xs' -> MatchClass -> Int -> [b] -> Match b
forall a. MatchClass -> Int -> [a] -> Match a
Match (MatchClass -> MatchClass -> MatchClass
forall a. Ord a => a -> a -> a
min MatchClass
m MatchClass
m') (Int
d Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
d') [b]
xs'
NoMatch Int
d' [MatchError]
ms -> Int -> [MatchError] -> Match b
forall a. Int -> [MatchError] -> Match a
NoMatch (Int
d Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
d') [MatchError]
ms
instance MonadPlus Match where
mzero :: forall a. Match a
mzero = Match a
forall a. Match a
forall (f :: * -> *) a. Alternative f => f a
empty
mplus :: forall a. Match a -> Match a -> Match a
mplus = Match a -> Match a -> Match a
forall a. Match a -> Match a -> Match a
matchPlus
(</>) :: Match a -> Match a -> Match a
</> :: forall a. Match a -> Match a -> Match a
(</>) = Match a -> Match a -> Match a
forall a. Match a -> Match a -> Match a
matchPlusShadowing
infixl 3 </>
matchPlus :: Match a -> Match a -> Match a
matchPlus :: forall a. Match a -> Match a -> Match a
matchPlus a :: Match a
a@(Match MatchClass
_ Int
_ [a]
_) (NoMatch Int
_ [MatchError]
_) = Match a
a
matchPlus (NoMatch Int
_ [MatchError]
_) b :: Match a
b@(Match MatchClass
_ Int
_ [a]
_) = Match a
b
matchPlus a :: Match a
a@(NoMatch Int
d_a [MatchError]
ms_a) b :: Match a
b@(NoMatch Int
d_b [MatchError]
ms_b)
| Int
d_a Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
d_b = Match a
a
| Int
d_a Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
d_b = Match a
b
| Bool
otherwise = Int -> [MatchError] -> Match a
forall a. Int -> [MatchError] -> Match a
NoMatch Int
d_a ([MatchError]
ms_a [MatchError] -> [MatchError] -> [MatchError]
forall a. [a] -> [a] -> [a]
++ [MatchError]
ms_b)
matchPlus a :: Match a
a@(Match MatchClass
m_a Int
d_a [a]
xs_a) b :: Match a
b@(Match MatchClass
m_b Int
d_b [a]
xs_b)
| MatchClass
m_a MatchClass -> MatchClass -> Bool
forall a. Ord a => a -> a -> Bool
> MatchClass
m_b = Match a
a
| MatchClass
m_a MatchClass -> MatchClass -> Bool
forall a. Ord a => a -> a -> Bool
< MatchClass
m_b = Match a
b
| Bool
otherwise = MatchClass -> Int -> [a] -> Match a
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
m_a (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
d_a Int
d_b) ([a]
xs_a [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a]
xs_b)
matchPlusShadowing :: Match a -> Match a -> Match a
matchPlusShadowing :: forall a. Match a -> Match a -> Match a
matchPlusShadowing a :: Match a
a@(Match MatchClass
Exact Int
_ [a]
_) Match a
_ = Match a
a
matchPlusShadowing Match a
a Match a
b = Match a -> Match a -> Match a
forall a. Match a -> Match a -> Match a
matchPlus Match a
a Match a
b
matchErrorExpected :: String -> String -> Match a
matchErrorExpected :: forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
thing [Char]
got = Int -> [MatchError] -> Match a
forall a. Int -> [MatchError] -> Match a
NoMatch Int
0 [[Char] -> [Char] -> MatchError
MatchErrorExpected [Char]
thing [Char]
got]
matchErrorNoSuch :: String -> String -> [String] -> Match a
matchErrorNoSuch :: forall a. [Char] -> [Char] -> [[Char]] -> Match a
matchErrorNoSuch [Char]
thing [Char]
got [[Char]]
alts = Int -> [MatchError] -> Match a
forall a. Int -> [MatchError] -> Match a
NoMatch Int
0 [[Char] -> [Char] -> [[Char]] -> MatchError
MatchErrorNoSuch [Char]
thing [Char]
got [[Char]]
alts]
expecting :: String -> String -> Match a -> Match a
expecting :: forall a. [Char] -> [Char] -> Match a -> Match a
expecting [Char]
thing [Char]
got (NoMatch Int
0 [MatchError]
_) = [Char] -> [Char] -> Match a
forall a. [Char] -> [Char] -> Match a
matchErrorExpected [Char]
thing [Char]
got
expecting [Char]
_ [Char]
_ Match a
m = Match a
m
orNoSuchThing :: String -> String -> [String] -> Match a -> Match a
orNoSuchThing :: forall a. [Char] -> [Char] -> [[Char]] -> Match a -> Match a
orNoSuchThing [Char]
thing [Char]
got [[Char]]
alts (NoMatch Int
0 [MatchError]
_) = [Char] -> [Char] -> [[Char]] -> Match a
forall a. [Char] -> [Char] -> [[Char]] -> Match a
matchErrorNoSuch [Char]
thing [Char]
got [[Char]]
alts
orNoSuchThing [Char]
_ [Char]
_ [[Char]]
_ Match a
m = Match a
m
orNoThingIn :: String -> String -> Match a -> Match a
orNoThingIn :: forall a. [Char] -> [Char] -> Match a -> Match a
orNoThingIn [Char]
kind [Char]
name (NoMatch Int
n [MatchError]
ms) =
Int -> [MatchError] -> Match a
forall a. Int -> [MatchError] -> Match a
NoMatch Int
n [[Char] -> [Char] -> MatchError -> MatchError
MatchErrorIn [Char]
kind [Char]
name MatchError
m | MatchError
m <- [MatchError]
ms]
orNoThingIn [Char]
_ [Char]
_ Match a
m = Match a
m
increaseConfidence :: Match ()
increaseConfidence :: Match ()
increaseConfidence = MatchClass -> Int -> [()] -> Match ()
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
Exact Int
1 [()]
increaseConfidenceFor :: Match a -> Match a
increaseConfidenceFor :: forall a. Match a -> Match a
increaseConfidenceFor Match a
m = Match a
m Match a -> (a -> Match a) -> Match a
forall a b. Match a -> (a -> Match b) -> Match b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
r -> Match ()
increaseConfidence Match () -> Match a -> Match a
forall a b. Match a -> Match b -> Match b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Match a
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return a
r
nubMatchesBy :: (a -> a -> Bool) -> Match a -> Match a
nubMatchesBy :: forall a. (a -> a -> Bool) -> Match a -> Match a
nubMatchesBy a -> a -> Bool
_ (NoMatch Int
d [MatchError]
msgs) = Int -> [MatchError] -> Match a
forall a. Int -> [MatchError] -> Match a
NoMatch Int
d [MatchError]
msgs
nubMatchesBy a -> a -> Bool
eq (Match MatchClass
m Int
d [a]
xs) = MatchClass -> Int -> [a] -> Match a
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
m Int
d ((a -> a -> Bool) -> [a] -> [a]
forall a. (a -> a -> Bool) -> [a] -> [a]
nubBy a -> a -> Bool
eq [a]
xs)
exactMatches, inexactMatches :: [a] -> Match a
exactMatches :: forall a. [a] -> Match a
exactMatches [] = Match a
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
exactMatches [a]
xs = MatchClass -> Int -> [a] -> Match a
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
Exact Int
0 [a]
xs
inexactMatches :: forall a. [a] -> Match a
inexactMatches [] = Match a
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
inexactMatches [a]
xs = MatchClass -> Int -> [a] -> Match a
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
Inexact Int
0 [a]
xs
unknownMatch :: a -> Match a
unknownMatch :: forall a. a -> Match a
unknownMatch a
x = MatchClass -> Int -> [a] -> Match a
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
Unknown Int
0 [a
x]
tryEach :: [a] -> Match a
tryEach :: forall a. [a] -> Match a
tryEach = [a] -> Match a
forall a. [a] -> Match a
exactMatches
findMatch :: Match a -> MaybeAmbiguous a
findMatch :: forall a. Match a -> MaybeAmbiguous a
findMatch Match a
match = case Match a
match of
NoMatch Int
_ [MatchError]
msgs -> [MatchError] -> MaybeAmbiguous a
forall a. [MatchError] -> MaybeAmbiguous a
None [MatchError]
msgs
Match MatchClass
_ Int
_ [a
x] -> a -> MaybeAmbiguous a
forall a. a -> MaybeAmbiguous a
Unambiguous a
x
Match MatchClass
m Int
d [] -> [Char] -> MaybeAmbiguous a
forall a. HasCallStack => [Char] -> a
error ([Char] -> MaybeAmbiguous a) -> [Char] -> MaybeAmbiguous a
forall a b. (a -> b) -> a -> b
$ [Char]
"findMatch: impossible: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Match () -> [Char]
forall a. Show a => a -> [Char]
show Match ()
match'
where
match' :: Match ()
match' = MatchClass -> Int -> [()] -> Match ()
forall a. MatchClass -> Int -> [a] -> Match a
Match MatchClass
m Int
d [] :: Match ()
Match MatchClass
m Int
_ [a]
xs -> MatchClass -> [a] -> MaybeAmbiguous a
forall a. MatchClass -> [a] -> MaybeAmbiguous a
Ambiguous MatchClass
m [a]
xs
data MaybeAmbiguous a
= None [MatchError]
| Unambiguous a
| Ambiguous MatchClass [a]
deriving (Int -> MaybeAmbiguous a -> ShowS
[MaybeAmbiguous a] -> ShowS
MaybeAmbiguous a -> [Char]
(Int -> MaybeAmbiguous a -> ShowS)
-> (MaybeAmbiguous a -> [Char])
-> ([MaybeAmbiguous a] -> ShowS)
-> Show (MaybeAmbiguous a)
forall a. Show a => Int -> MaybeAmbiguous a -> ShowS
forall a. Show a => [MaybeAmbiguous a] -> ShowS
forall a. Show a => MaybeAmbiguous a -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MaybeAmbiguous a -> ShowS
showsPrec :: Int -> MaybeAmbiguous a -> ShowS
$cshow :: forall a. Show a => MaybeAmbiguous a -> [Char]
show :: MaybeAmbiguous a -> [Char]
$cshowList :: forall a. Show a => [MaybeAmbiguous a] -> ShowS
showList :: [MaybeAmbiguous a] -> ShowS
Show)
matchExactly :: Ord k => (a -> k) -> [a] -> (k -> Match a)
matchExactly :: forall k a. Ord k => (a -> k) -> [a] -> k -> Match a
matchExactly a -> k
key [a]
xs =
\k
k -> case k -> Map k [a] -> Maybe [a]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup k
k Map k [a]
m of
Maybe [a]
Nothing -> Match a
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
Just [a]
ys -> [a] -> Match a
forall a. [a] -> Match a
exactMatches [a]
ys
where
m :: Map k [a]
m = ([a] -> [a] -> [a]) -> [(k, [a])] -> Map k [a]
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
(++) [(a -> k
key a
x, [a
x]) | a
x <- [a]
xs]
matchInexactly
:: (Ord k, Ord k')
=> (k -> k')
-> (a -> k)
-> [a]
-> (k -> Match a)
matchInexactly :: forall k k' a.
(Ord k, Ord k') =>
(k -> k') -> (a -> k) -> [a] -> k -> Match a
matchInexactly k -> k'
cannonicalise a -> k
key [a]
xs =
\k
k -> case k -> Map k [a] -> Maybe [a]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup k
k Map k [a]
m of
Just [a]
ys -> [a] -> Match a
forall a. [a] -> Match a
exactMatches [a]
ys
Maybe [a]
Nothing -> case k' -> Map k' [a] -> Maybe [a]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (k -> k'
cannonicalise k
k) Map k' [a]
m' of
Just [a]
ys -> [a] -> Match a
forall a. [a] -> Match a
inexactMatches [a]
ys
Maybe [a]
Nothing -> Match a
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
where
m :: Map k [a]
m = ([a] -> [a] -> [a]) -> [(k, [a])] -> Map k [a]
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
(++) [(a -> k
key a
x, [a
x]) | a
x <- [a]
xs]
m' :: Map k' [a]
m' = ([a] -> [a] -> [a]) -> (k -> k') -> Map k [a] -> Map k' [a]
forall k2 a k1.
Ord k2 =>
(a -> a -> a) -> (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeysWith [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
(++) k -> k'
cannonicalise Map k [a]
m
matchParse :: Parsec a => String -> Match a
matchParse :: forall a. Parsec a => [Char] -> Match a
matchParse = Match a -> (a -> Match a) -> Maybe a -> Match a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Match a
forall a. Match a
forall (m :: * -> *) a. MonadPlus m => m a
mzero a -> Match a
forall a. a -> Match a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a -> Match a) -> ([Char] -> Maybe a) -> [Char] -> Match a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Maybe a
forall a. Parsec a => [Char] -> Maybe a
simpleParsec
caseFold :: String -> String
caseFold :: ShowS
caseFold = ShowS
lowercase
mkComponentName
:: PackageName
-> ComponentKind
-> UnqualComponentName
-> ComponentName
mkComponentName :: PackageName
-> ComponentKind -> UnqualComponentName -> ComponentName
mkComponentName PackageName
pkgname ComponentKind
ckind UnqualComponentName
ucname =
case ComponentKind
ckind of
ComponentKind
LibKind
| PackageName -> UnqualComponentName
packageNameToUnqualComponentName PackageName
pkgname UnqualComponentName -> UnqualComponentName -> Bool
forall a. Eq a => a -> a -> Bool
== UnqualComponentName
ucname ->
LibraryName -> ComponentName
CLibName LibraryName
LMainLibName
| Bool
otherwise -> LibraryName -> ComponentName
CLibName (LibraryName -> ComponentName) -> LibraryName -> ComponentName
forall a b. (a -> b) -> a -> b
$ UnqualComponentName -> LibraryName
LSubLibName UnqualComponentName
ucname
ComponentKind
FLibKind -> UnqualComponentName -> ComponentName
CFLibName UnqualComponentName
ucname
ComponentKind
ExeKind -> UnqualComponentName -> ComponentName
CExeName UnqualComponentName
ucname
ComponentKind
TestKind -> UnqualComponentName -> ComponentName
CTestName UnqualComponentName
ucname
ComponentKind
BenchKind -> UnqualComponentName -> ComponentName
CBenchName UnqualComponentName
ucname