module Linspire.Debian.PackageDeprecated where
import qualified Data.Map as Map
import Linspire.Debian.Version
import Linspire.Debian.Control
import Linspire.Debian.Relation
import Linspire.Debian.Package
data Package
= Package { pName :: String
, pVersion :: Maybe DebianVersion
, pDepends :: Relations
, pPreDepends :: Relations
, pConflicts ::Relations
, pReplaces :: Relations
, pProvides :: Relations
}
deriving Show
instance Eq Package where
p1 == p2 = (pName p1 == pName p2) && (pVersion p1 == pVersion p2)
paragraphToPackages :: Paragraph -> Package
paragraphToPackages p =
Package { pName =
case lookupP "Package" p of
Nothing -> error $ "Paragraph does not have Package field: " ++ (show p)
Just (Field (_,a)) -> stripWS a
, pVersion =
case lookupP "Version" p of
Nothing -> error $ "Version not found for " ++ show p
Just (Field (_,a)) -> Just (parseDebianVersion (stripWS a))
, pDepends = tryParseRel $ lookupP "Depends" p
, pPreDepends = tryParseRel $ lookupP "Pre-Depends" p
, pConflicts = tryParseRel $ lookupP "Conflicts" p
, pReplaces = tryParseRel $ lookupP "Replaces" p
, pProvides = tryParseRel $ lookupP "Provides" p
}
type ProvidesMap = Map.Map String [Package]
findProvides :: [Package] -> [(PkgName, Package)]
findProvides packages = foldl addprovides [] packages
where addprovides :: [(PkgName, Package)] -> Package -> [(PkgName, Package)]
addprovides providesList package =
foldl (\pl [(Rel pkgName Nothing Nothing)] ->(pkgName, package): pl) providesList (pProvides package)
makeVirtualPackages :: ProvidesMap -> [Package]
makeVirtualPackages pm =
Map.foldWithKey mVP [] pm
where mVP vpName packages virtualPackages
= (Package { pName = vpName
, pVersion = Nothing
, pDepends = [map mkDepend packages]
, pPreDepends = []
, pConflicts = []
, pReplaces = []
, pProvides = []
} ) : virtualPackages
mkDepend package =
let name = pName package
rel = fmap EEQ (pVersion package)
in Rel name rel Nothing
controlToPackageNameMap :: Control -> (Paragraph -> Package) -> PackageNameMap Package
controlToPackageNameMap (Control p) p2p =
let packages = (map p2p p) in
addProvides (map (\ (Rel pkgName _ _) -> pkgName) . concat . pProvides) packages (packageNameMap pName packages)
packagesToPackageNameMap :: [Package] -> PackageNameMap Package
packagesToPackageNameMap packages =
addProvides (map (\ (Rel pkgName _ _) -> pkgName) . concat . pProvides) packages (packageNameMap pName packages)
lookupPackageByRel :: PackageNameMap Package -> Relation -> [Package]
lookupPackageByRel pm (Rel pkgName mVerReq _) =
case Map.lookup pkgName pm of
Nothing -> []
Just packages -> filter filterVer packages
where filterVer p =
case mVerReq of
Nothing -> True
Just _ ->
if (pName p) /= pkgName
then False
else checkVersionReq mVerReq (pVersion p)
tryParseRel :: Maybe Field -> Relations
tryParseRel Nothing = []
tryParseRel (Just (Field (_, relStr))) = either (error . show) id (parseRelations relStr)