packages feed

kenshou-core-0.1.0.0: src/Kenshou/Plan/Components/Check.hs

{-# LANGUAGE FieldSelectors #-}

module Kenshou.Plan.Components.Check
  ( PackageName (..),
    EdgeDrift (..),
    LintFinding (..),
    checkAgainstPlanJson,
    lintAgainstCatalog,
    isDriftError,
    isLintError,
  )
where

import Data.Aeson
import Data.ByteString qualified as ByteString
import Data.List (nub, sort)
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Set (Set)
import Data.Set qualified as Set
import Data.Text (Text)
import Data.Text qualified as Text
import Kenshou.Core.Id (ScenarioId (..), renderScenarioId, selftestLayer)
import Kenshou.Plan.Catalog (ScenarioInfo (..))
import Kenshou.Plan.Components
import Kenshou.Plan.Selector (Selector, matches, renderSelector)

newtype PackageName = PackageName Text
  deriving stock (Eq, Ord, Show)

data EdgeDrift
  = MissingEdge ComponentId ComponentId [PackageName]
  | ExtraEdge ComponentId ComponentId
  | NotInBuildPlan PackageName
  deriving stock (Eq, Ord, Show)

data LintFinding
  = OrphanScenario ScenarioId
  | DeadSelector ComponentRef Selector
  deriving stock (Eq, Show)

data PlanUnit = PlanUnit {unitId :: Text, package :: PackageName, componentName :: Maybe Text, dependencies :: [Text]}

newtype CabalPlan = CabalPlan {units :: [PlanUnit]}

instance FromJSON CabalPlan where parseJSON = withObject "CabalPlan" \value -> CabalPlan <$> value .: "install-plan"

instance FromJSON PlanUnit where
  parseJSON = withObject "PlanUnit" \value ->
    PlanUnit <$> value .: "id" <*> (PackageName <$> value .: "pkg-name") <*> value .:? "component-name" <*> value .:? "depends" .!= []

checkAgainstPlanJson :: ComponentGraph -> FilePath -> IO (Either Text [EdgeDrift])
checkAgainstPlanJson graph path = do
  bytes <- ByteString.readFile path
  pure case eitherDecodeStrict' bytes of
    Left err -> Left (Text.pack err)
    Right plan -> Right (compareEdges graph plan)

compareEdges :: ComponentGraph -> CabalPlan -> [EdgeDrift]
compareEdges graph plan =
  fmap (uncurry missingEdgeWithPackages) missing
    <> fmap (uncurry ExtraEdge) extra
    <> fmap (NotInBuildPlan . PackageName) absentPackages
  where
    libraryUnits = filter ((== Just "lib") . (.componentName)) plan.units
    idToPackage = Map.fromList [(unit.unitId, unit.package) | unit <- plan.units]
    packageToComponent = Map.fromList [(PackageName package, componentValue.id) | componentValue <- graph.components, package <- componentValue.packages]
    presentPackages = Set.fromList (fmap (.package) libraryUnits)
    presentComponents = Set.fromList (Map.elems (Map.restrictKeys packageToComponent presentPackages))
    observed = Set.fromList do
      unit <- libraryUnits
      source <- maybe [] pure (Map.lookup unit.package packageToComponent)
      dependencyId <- unit.dependencies
      dependencyPackage <- maybe [] pure (Map.lookup dependencyId idToPackage)
      target <- maybe [] pure (Map.lookup dependencyPackage packageToComponent)
      if source == target then [] else pure (source, target)
    declared = Set.fromList [(componentValue.id, edge.to) | componentValue <- graph.components, edge <- componentValue.dependsOn, edge.kind == Build, componentValue.id `Set.member` presentComponents, edge.to `Set.member` presentComponents]
    missing = Set.toAscList (observed `Set.difference` declared)
    extra = Set.toAscList (declared `Set.difference` observed)
    absentPackages = sort [package | componentValue <- graph.components, package <- componentValue.packages, PackageName package `Set.notMember` presentPackages]
    directPackages source target =
      nub
        [ dependencyPackage
        | unit <- libraryUnits,
          Map.lookup unit.package packageToComponent == Just source,
          dependencyId <- unit.dependencies,
          Just dependencyPackage <- [Map.lookup dependencyId idToPackage],
          Map.lookup dependencyPackage packageToComponent == Just target
        ]
    missingEdgeWithPackages source target = MissingEdge source target (directPackages source target)

lintAgainstCatalog :: ComponentGraph -> [ScenarioInfo] -> [LintFinding]
lintAgainstCatalog graph catalog = orphaned <> dead
  where
    references =
      [ComponentRef componentValue.id Nothing | componentValue <- graph.components]
        <> [ComponentRef componentValue.id (Just subcomponentValue.id) | componentValue <- graph.components, subcomponentValue <- componentValue.subcomponents]
    selectorPairs = [(reference, selector) | reference <- references, selector <- selectorsForRef graph reference]
    orphaned =
      [ OrphanScenario scenario.id
      | scenario <- catalog,
        scenario.id.layer /= selftestLayer,
        not (any ((`matches` scenario.id) . snd) selectorPairs)
      ]
    dead =
      [ DeadSelector reference selector
      | (reference, selector) <- selectorPairs,
        selectorHasRegisteredLayer selector,
        not (any (matches selector . (.id)) catalog)
      ]
    selectorHasRegisteredLayer selector =
      let prefix = Text.takeWhile (/= '/') (renderSelector selector)
       in prefix == "*" || any ((== prefix) . Text.takeWhile (/= '/') . renderScenarioId . (.id)) catalog

isDriftError :: EdgeDrift -> Bool
isDriftError NotInBuildPlan {} = False
isDriftError _ = True

isLintError :: LintFinding -> Bool
isLintError OrphanScenario {} = True
isLintError DeadSelector {} = False