module Data.Yaml.Marked
  ( Marked (..)
  , Location (..)

    -- * Interop with "Data.Yaml"
  , MarkedEvent
  , fromMarkedEvent
  ) where

import Prelude

import Data.Aeson (JSONPath)
import Numeric.Natural
import Text.Libyaml (Event, MarkedEvent (..), YamlMark (..))

data Marked a = Marked
  { forall a. Marked a -> a
markedItem :: a
  , forall a. Marked a -> FilePath
markedPath :: FilePath
  , forall a. Marked a -> Maybe JSONPath
markedJSONPath :: Maybe JSONPath
  , forall a. Marked a -> Location
markedLocationStart :: Location
  -- ^ Location of the first character of the item
  --
  -- In the following example, marking @value@ will have a start location:
  --
  -- @
  -- key: value\n
  --      ^-- HERE
  -- @
  , forall a. Marked a -> Location
markedLocationEnd :: Location
  -- ^ Location of the first character /after/ the item
  --
  -- In the following example, marking @value@ will have an end location:
  --
  -- @
  -- key: value\n
  --           ^-- HERE
  -- @
  }
  deriving stock (Marked a -> Marked a -> Bool
(Marked a -> Marked a -> Bool)
-> (Marked a -> Marked a -> Bool) -> Eq (Marked a)
forall a. Eq a => Marked a -> Marked a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Marked a -> Marked a -> Bool
== :: Marked a -> Marked a -> Bool
$c/= :: forall a. Eq a => Marked a -> Marked a -> Bool
/= :: Marked a -> Marked a -> Bool
Eq, Int -> Marked a -> ShowS
[Marked a] -> ShowS
Marked a -> FilePath
(Int -> Marked a -> ShowS)
-> (Marked a -> FilePath)
-> ([Marked a] -> ShowS)
-> Show (Marked a)
forall a. Show a => Int -> Marked a -> ShowS
forall a. Show a => [Marked a] -> ShowS
forall a. Show a => Marked a -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Marked a -> ShowS
showsPrec :: Int -> Marked a -> ShowS
$cshow :: forall a. Show a => Marked a -> FilePath
show :: Marked a -> FilePath
$cshowList :: forall a. Show a => [Marked a] -> ShowS
showList :: [Marked a] -> ShowS
Show, (forall a b. (a -> b) -> Marked a -> Marked b)
-> (forall a b. a -> Marked b -> Marked a) -> Functor Marked
forall a b. a -> Marked b -> Marked a
forall a b. (a -> b) -> Marked a -> Marked b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Marked a -> Marked b
fmap :: forall a b. (a -> b) -> Marked a -> Marked b
$c<$ :: forall a b. a -> Marked b -> Marked a
<$ :: forall a b. a -> Marked b -> Marked a
Functor, (forall m. Monoid m => Marked m -> m)
-> (forall m a. Monoid m => (a -> m) -> Marked a -> m)
-> (forall m a. Monoid m => (a -> m) -> Marked a -> m)
-> (forall a b. (a -> b -> b) -> b -> Marked a -> b)
-> (forall a b. (a -> b -> b) -> b -> Marked a -> b)
-> (forall b a. (b -> a -> b) -> b -> Marked a -> b)
-> (forall b a. (b -> a -> b) -> b -> Marked a -> b)
-> (forall a. (a -> a -> a) -> Marked a -> a)
-> (forall a. (a -> a -> a) -> Marked a -> a)
-> (forall a. Marked a -> [a])
-> (forall a. Marked a -> Bool)
-> (forall a. Marked a -> Int)
-> (forall a. Eq a => a -> Marked a -> Bool)
-> (forall a. Ord a => Marked a -> a)
-> (forall a. Ord a => Marked a -> a)
-> (forall a. Num a => Marked a -> a)
-> (forall a. Num a => Marked a -> a)
-> Foldable Marked
forall a. Eq a => a -> Marked a -> Bool
forall a. Num a => Marked a -> a
forall a. Ord a => Marked a -> a
forall m. Monoid m => Marked m -> m
forall a. Marked a -> Bool
forall a. Marked a -> Int
forall a. Marked a -> [a]
forall a. (a -> a -> a) -> Marked a -> a
forall m a. Monoid m => (a -> m) -> Marked a -> m
forall b a. (b -> a -> b) -> b -> Marked a -> b
forall a b. (a -> b -> b) -> b -> Marked a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Marked m -> m
fold :: forall m. Monoid m => Marked m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Marked a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Marked a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Marked a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Marked a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Marked a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Marked a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Marked a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Marked a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Marked a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Marked a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Marked a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Marked a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Marked a -> a
foldr1 :: forall a. (a -> a -> a) -> Marked a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Marked a -> a
foldl1 :: forall a. (a -> a -> a) -> Marked a -> a
$ctoList :: forall a. Marked a -> [a]
toList :: forall a. Marked a -> [a]
$cnull :: forall a. Marked a -> Bool
null :: forall a. Marked a -> Bool
$clength :: forall a. Marked a -> Int
length :: forall a. Marked a -> Int
$celem :: forall a. Eq a => a -> Marked a -> Bool
elem :: forall a. Eq a => a -> Marked a -> Bool
$cmaximum :: forall a. Ord a => Marked a -> a
maximum :: forall a. Ord a => Marked a -> a
$cminimum :: forall a. Ord a => Marked a -> a
minimum :: forall a. Ord a => Marked a -> a
$csum :: forall a. Num a => Marked a -> a
sum :: forall a. Num a => Marked a -> a
$cproduct :: forall a. Num a => Marked a -> a
product :: forall a. Num a => Marked a -> a
Foldable, Functor Marked
Foldable Marked
(Functor Marked, Foldable Marked) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Marked a -> f (Marked b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Marked (f a) -> f (Marked a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Marked a -> m (Marked b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Marked (m a) -> m (Marked a))
-> Traversable Marked
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Marked (m a) -> m (Marked a)
forall (f :: * -> *) a.
Applicative f =>
Marked (f a) -> f (Marked a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Marked a -> m (Marked b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Marked a -> f (Marked b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Marked a -> f (Marked b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Marked a -> f (Marked b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Marked (f a) -> f (Marked a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Marked (f a) -> f (Marked a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Marked a -> m (Marked b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Marked a -> m (Marked b)
$csequence :: forall (m :: * -> *) a. Monad m => Marked (m a) -> m (Marked a)
sequence :: forall (m :: * -> *) a. Monad m => Marked (m a) -> m (Marked a)
Traversable)

-- | Index, line, and column of a character
--
-- NB. All values are 0-based.
data Location = Location
  { Location -> Natural
locationIndex :: Natural
  , Location -> Natural
locationLine :: Natural
  , Location -> Natural
locationColumn :: Natural
  }
  deriving stock (Location -> Location -> Bool
(Location -> Location -> Bool)
-> (Location -> Location -> Bool) -> Eq Location
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Location -> Location -> Bool
== :: Location -> Location -> Bool
$c/= :: Location -> Location -> Bool
/= :: Location -> Location -> Bool
Eq, Int -> Location -> ShowS
[Location] -> ShowS
Location -> FilePath
(Int -> Location -> ShowS)
-> (Location -> FilePath) -> ([Location] -> ShowS) -> Show Location
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Location -> ShowS
showsPrec :: Int -> Location -> ShowS
$cshow :: Location -> FilePath
show :: Location -> FilePath
$cshowList :: [Location] -> ShowS
showList :: [Location] -> ShowS
Show)

locationFromYamlMark :: YamlMark -> Location
locationFromYamlMark :: YamlMark -> Location
locationFromYamlMark YamlMark {Int
yamlIndex :: Int
yamlLine :: Int
yamlColumn :: Int
yamlIndex :: YamlMark -> Int
yamlLine :: YamlMark -> Int
yamlColumn :: YamlMark -> Int
..} =
  Location
    { locationIndex :: Natural
locationIndex = Int -> Natural
int2nat Int
yamlIndex
    , locationLine :: Natural
locationLine = Int -> Natural
int2nat Int
yamlLine
    , locationColumn :: Natural
locationColumn = Int -> Natural
int2nat Int
yamlColumn
    }

fromMarkedEvent :: MarkedEvent -> FilePath -> Marked Event
fromMarkedEvent :: MarkedEvent -> FilePath -> Marked Event
fromMarkedEvent MarkedEvent {YamlMark
Event
yamlEvent :: Event
yamlStartMark :: YamlMark
yamlEndMark :: YamlMark
yamlEvent :: MarkedEvent -> Event
yamlStartMark :: MarkedEvent -> YamlMark
yamlEndMark :: MarkedEvent -> YamlMark
..} FilePath
fp =
  Marked
    { markedItem :: Event
markedItem = Event
yamlEvent
    , markedPath :: FilePath
markedPath = FilePath
fp
    , markedJSONPath :: Maybe JSONPath
markedJSONPath = Maybe JSONPath
forall a. Maybe a
Nothing
    , markedLocationStart :: Location
markedLocationStart = YamlMark -> Location
locationFromYamlMark YamlMark
yamlStartMark
    , markedLocationEnd :: Location
markedLocationEnd = YamlMark -> Location
locationFromYamlMark YamlMark
yamlEndMark
    }

int2nat :: Int -> Natural
int2nat :: Int -> Natural
int2nat = Int -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Natural) -> (Int -> Int) -> Int -> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0