packages feed

kenshou-core-0.1.0.0: src/Kenshou/Core/Id.hs

module Kenshou.Core.Id
  ( LayerId,
    Kind (..),
    Segment,
    ScenarioId (..),
    RunId,
    Seed,
    mkLayerId,
    selftestLayer,
    renderLayer,
    parseLayer,
    renderKind,
    parseKind,
    mkSegment,
    unSegment,
    parseScenarioId,
    renderScenarioId,
    newRunId,
    parseRunId,
    renderRunId,
    mkSeed,
    unSeed,
    deriveGen,
  )
where

import Data.Aeson (FromJSON (..), ToJSON (..), withText)
import Data.Bits (xor)
import Data.ByteString qualified as ByteString
import Data.Char (isAsciiLower, isDigit)
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Text.Encoding qualified as Text
import Data.UUID (UUID)
import Data.UUID qualified as UUID
import Data.UUID.V7 qualified as UUID.V7
import Data.Word (Word64)
import System.Random.SplitMix (SMGen, mkSMGen)

-- | The first segment of a scenario identifier: the name of what a registered layer
-- bundle verifies. Any valid segment is a layer; suites choose their own.
newtype LayerId = LayerId Segment
  deriving stock (Eq, Ord, Show)

data Kind = Correctness | Concurrency | Soak | Benchmark
  deriving stock (Eq, Ord, Show, Enum, Bounded)

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

data ScenarioId = ScenarioId
  { layer :: LayerId,
    component :: Segment,
    kind :: Kind,
    name :: Segment
  }
  deriving stock (Eq, Ord, Show)

newtype RunId = RunId UUID
  deriving stock (Eq, Ord, Show)

newtype Seed = Seed Word64
  deriving stock (Eq, Ord, Show)

mkLayerId :: Text -> Either Text LayerId
mkLayerId value = either (\problem -> Left ("invalid layer \"" <> value <> "\": " <> problem)) (Right . LayerId) (mkSegment value)

-- | The layer of the kernel's and toolkits' own self-test scenarios.
selftestLayer :: LayerId
selftestLayer = LayerId (Segment "selftest")

renderLayer :: LayerId -> Text
renderLayer (LayerId segment) = unSegment segment

parseLayer :: Text -> Either Text LayerId
parseLayer = mkLayerId

renderKind :: Kind -> Text
renderKind Correctness = "correctness"
renderKind Concurrency = "concurrency"
renderKind Soak = "soak"
renderKind Benchmark = "benchmark"

parseKind :: Text -> Either Text Kind
parseKind value = maybe (Left ("unknown kind \"" <> value <> "\"")) Right (lookup value pairs)
  where
    pairs = [(renderKind item, item) | item <- [minBound .. maxBound]]

mkSegment :: Text -> Either Text Segment
mkSegment value
  | Text.length value > 48 = Left "segment is longer than 48 characters"
  | Text.null value = Left "segment is empty"
  | valid = Right (Segment value)
  | otherwise = Left ("invalid segment \"" <> value <> "\"")
  where
    chunks = Text.splitOn "-" value
    validChunk chunk =
      not (Text.null chunk)
        && isAsciiLower (Text.head chunk)
        && Text.all (\c -> isAsciiLower c || isDigit c) chunk
    valid = all validChunk chunks

unSegment :: Segment -> Text
unSegment (Segment value) = value

parseScenarioId :: Text -> Either Text ScenarioId
parseScenarioId value = case Text.splitOn "/" value of
  [layerText, componentText, kindText, nameText] ->
    ScenarioId
      <$> parseLayer layerText
      <*> mkSegment componentText
      <*> parseKind kindText
      <*> mkSegment nameText
  _ -> Left ("scenario identifier must have four segments: \"" <> value <> "\"")

renderScenarioId :: ScenarioId -> Text
renderScenarioId value =
  Text.intercalate
    "/"
    [renderLayer value.layer, unSegment value.component, renderKind value.kind, unSegment value.name]

newRunId :: IO RunId
newRunId = RunId <$> UUID.V7.genUUID

parseRunId :: Text -> Either Text RunId
parseRunId value = case UUID.fromText value of
  Nothing -> Left ("invalid UUIDv7 \"" <> value <> "\"")
  Just uuid
    | UUID.toText uuid /= value -> Left "run id must use canonical lowercase UUID text"
    | Text.index value 14 /= '7' -> Left "run id must be UUIDv7"
    | otherwise -> Right (RunId uuid)

renderRunId :: RunId -> Text
renderRunId (RunId uuid) = UUID.toText uuid

mkSeed :: Word64 -> Either Text Seed
mkSeed value
  | value <= 9007199254740991 = Right (Seed value)
  | otherwise = Left "seed must be between 0 and 9007199254740991"

unSeed :: Seed -> Word64
unSeed (Seed value) = value

deriveGen :: Seed -> Text -> SMGen
deriveGen (Seed seed) label = mkSMGen (seed `xor` fnv1a64 (Text.encodeUtf8 label))

fnv1a64 :: ByteString.ByteString -> Word64
fnv1a64 = ByteString.foldl' step 14695981039346656037
  where
    step hash byte = (hash `xor` fromIntegral byte) * 1099511628211

instance ToJSON LayerId where toJSON = toJSON . renderLayer

instance FromJSON LayerId where parseJSON = withText "LayerId" (either (fail . Text.unpack) pure . parseLayer)

instance ToJSON Kind where toJSON = toJSON . renderKind

instance FromJSON Kind where parseJSON = withText "Kind" (either (fail . Text.unpack) pure . parseKind)

instance ToJSON Segment where toJSON = toJSON . unSegment

instance FromJSON Segment where parseJSON = withText "Segment" (either (fail . Text.unpack) pure . mkSegment)

instance ToJSON ScenarioId where toJSON = toJSON . renderScenarioId

instance FromJSON ScenarioId where parseJSON = withText "ScenarioId" (either (fail . Text.unpack) pure . parseScenarioId)

instance ToJSON RunId where toJSON = toJSON . renderRunId

instance FromJSON RunId where parseJSON = withText "RunId" (either (fail . Text.unpack) pure . parseRunId)

instance ToJSON Seed where toJSON = toJSON . unSeed

instance FromJSON Seed where parseJSON value = parseJSON value >>= either (fail . Text.unpack) pure . mkSeed