{-# LANGUAGE LambdaCase #-}

--------------------------------------------------------------------------------
-- | This module provides you with a line-based editor. It's main feature is
-- that you can specify multiple changes at the same time, e.g.:
--
-- > [deleteLine 3, changeLine 4 ["Foo"]]
--
-- when this is evaluated, we take into account that 4th line will become the
-- 3rd line before it needs changing.
module Language.Haskell.Stylish.Editor
    ( module Language.Haskell.Stylish.Block

    , Edits
    , apply

    , replace
    , replaceRealSrcSpan
    , changeLine
    , changeLines
    , insertLines
    ) where


--------------------------------------------------------------------------------
import qualified Data.Map                       as M
import           Data.Maybe                     (fromMaybe)
import qualified GHC.Types.SrcLoc               as GHC


--------------------------------------------------------------------------------
import           Language.Haskell.Stylish.Block


--------------------------------------------------------------------------------
data Change
    -- | Insert some lines.
    = CInsert [String]
    -- | Replace the block of N lines by the given lines.
    | CBlock Int ([String] -> [String])
    -- | Replace (startCol, endCol) by the given string on this line.
    | CLine Int Int String


--------------------------------------------------------------------------------
-- | Due to the function in CBlock we cannot write a lawful Ord instance, but
-- this lets us merge-sort changes.
beforeChange :: Change -> Change -> Bool
beforeChange :: Change -> Change -> Bool
beforeChange (CInsert [String]
_)   Change
_             = Bool
True
beforeChange Change
_             (CInsert [String]
_)   = Bool
False
beforeChange (CBlock Int
_ [String] -> [String]
_)  Change
_             = Bool
True
beforeChange Change
_             (CBlock Int
_ [String] -> [String]
_)  = Bool
False
beforeChange (CLine Int
x Int
_ String
_) (CLine Int
y Int
_ String
_) = Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
y


--------------------------------------------------------------------------------
prettyChange :: Int -> Change -> String
prettyChange :: Int -> Change -> String
prettyChange Int
l (CInsert [String]
ls) =
    Int -> String
forall a. Show a => a -> String
show Int
l String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" insert " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show ([String] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
ls) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" lines"
prettyChange Int
l (CBlock Int
n [String] -> [String]
_) = Int -> String
forall a. Show a => a -> String
show Int
l String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"-" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show (Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" replace lines"
prettyChange Int
l (CLine Int
start Int
end String
x) =
    Int -> String
forall a. Show a => a -> String
show Int
l String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
":" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
start String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"-" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
end String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" replace by " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
x


--------------------------------------------------------------------------------
-- | Merge in order
mergeChanges :: [Change] -> [Change] -> [Change]
mergeChanges :: [Change] -> [Change] -> [Change]
mergeChanges = [Change] -> [Change] -> [Change]
go
  where
    go :: [Change] -> [Change] -> [Change]
go []       [Change]
ys       = [Change]
ys
    go [Change]
xs       []       = [Change]
xs
    go (Change
x : [Change]
xs) (Change
y : [Change]
ys) =
        if Change
x Change -> Change -> Bool
`beforeChange` Change
y then Change
x Change -> [Change] -> [Change]
forall a. a -> [a] -> [a]
: [Change] -> [Change] -> [Change]
go [Change]
xs (Change
y Change -> [Change] -> [Change]
forall a. a -> [a] -> [a]
: [Change]
ys) else Change
y Change -> [Change] -> [Change]
forall a. a -> [a] -> [a]
: [Change] -> [Change] -> [Change]
go (Change
x Change -> [Change] -> [Change]
forall a. a -> [a] -> [a]
: [Change]
xs) [Change]
ys


--------------------------------------------------------------------------------
-- Stores sorted spans to change per line.
newtype Edits = Edits {Edits -> Map Int [Change]
unEdits :: M.Map Int [Change]}


--------------------------------------------------------------------------------
instance Show Edits where
    show :: Edits -> String
show Edits
edits = [String] -> String
unlines ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ do
        (Int
line, [Change]
changes) <- Map Int [Change] -> [(Int, [Change])]
forall k a. Map k a -> [(k, a)]
M.toAscList (Map Int [Change] -> [(Int, [Change])])
-> Map Int [Change] -> [(Int, [Change])]
forall a b. (a -> b) -> a -> b
$ Edits -> Map Int [Change]
unEdits Edits
edits
        Int -> Change -> String
prettyChange Int
line (Change -> String) -> [Change] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Change]
changes


--------------------------------------------------------------------------------
instance Semigroup Edits where
    Edits Map Int [Change]
l <> :: Edits -> Edits -> Edits
<> Edits Map Int [Change]
r = Map Int [Change] -> Edits
Edits (Map Int [Change] -> Edits) -> Map Int [Change] -> Edits
forall a b. (a -> b) -> a -> b
$ ([Change] -> [Change] -> [Change])
-> Map Int [Change] -> Map Int [Change] -> Map Int [Change]
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
M.unionWith [Change] -> [Change] -> [Change]
mergeChanges Map Int [Change]
l Map Int [Change]
r


--------------------------------------------------------------------------------
instance Monoid Edits where
    mempty :: Edits
mempty = Map Int [Change] -> Edits
Edits Map Int [Change]
forall a. Monoid a => a
mempty


--------------------------------------------------------------------------------
replaceRealSrcSpan :: GHC.RealSrcSpan -> String -> Edits
replaceRealSrcSpan :: RealSrcSpan -> String -> Edits
replaceRealSrcSpan RealSrcSpan
rss String
repl
    | RealSrcSpan -> Int
GHC.srcSpanStartLine RealSrcSpan
rss Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= RealSrcSpan -> Int
GHC.srcSpanEndLine RealSrcSpan
rss = Edits
forall a. Monoid a => a
mempty
    | Bool
otherwise                                          = Int -> Int -> Int -> String -> Edits
replace
        (RealSrcSpan -> Int
GHC.srcSpanStartLine RealSrcSpan
rss)
        (RealSrcSpan -> Int
GHC.srcSpanStartCol RealSrcSpan
rss)
        (RealSrcSpan -> Int
GHC.srcSpanEndCol RealSrcSpan
rss)
        String
repl


--------------------------------------------------------------------------------
replace :: Int -> Int -> Int -> String -> Edits
replace :: Int -> Int -> Int -> String -> Edits
replace Int
line Int
startCol Int
endCol String
repl
    | Int
startCol Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
endCol = Edits
forall a. Monoid a => a
mempty
    | Bool
otherwise         =
        Map Int [Change] -> Edits
Edits (Map Int [Change] -> Edits) -> Map Int [Change] -> Edits
forall a b. (a -> b) -> a -> b
$ Int -> [Change] -> Map Int [Change]
forall k a. k -> a -> Map k a
M.singleton Int
line [Int -> Int -> String -> Change
CLine Int
startCol Int
endCol String
repl]


--------------------------------------------------------------------------------
changeLine :: Int -> (String -> [String]) -> Edits
changeLine :: Int -> (String -> [String]) -> Edits
changeLine Int
start String -> [String]
f = Block String -> ([String] -> [String]) -> Edits
changeLines (Int -> Int -> Block String
forall a. Int -> Int -> Block a
Block Int
start Int
start) (([String] -> [String]) -> Edits)
-> ([String] -> [String]) -> Edits
forall a b. (a -> b) -> a -> b
$ \[String]
ls -> case [String]
ls of
    String
l : [String]
_ -> String -> [String]
f String
l
    [String]
_     -> String -> [String]
f String
""


--------------------------------------------------------------------------------
changeLines :: Block String -> ([String] -> [String]) -> Edits
changeLines :: Block String -> ([String] -> [String]) -> Edits
changeLines (Block Int
start Int
end) [String] -> [String]
f =
    Map Int [Change] -> Edits
Edits (Map Int [Change] -> Edits) -> Map Int [Change] -> Edits
forall a b. (a -> b) -> a -> b
$ Int -> [Change] -> Map Int [Change]
forall k a. k -> a -> Map k a
M.singleton Int
start [Int -> ([String] -> [String]) -> Change
CBlock (Int
end Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
start Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) [String] -> [String]
f]


--------------------------------------------------------------------------------
insertLines :: Int -> [String] -> Edits
insertLines :: Int -> [String] -> Edits
insertLines Int
line [String]
ls = Map Int [Change] -> Edits
Edits (Map Int [Change] -> Edits) -> Map Int [Change] -> Edits
forall a b. (a -> b) -> a -> b
$ Int -> [Change] -> Map Int [Change]
forall k a. k -> a -> Map k a
M.singleton Int
line [[String] -> Change
CInsert [String]
ls]


--------------------------------------------------------------------------------
data Conflict = Conflict Int Change Int Change


--------------------------------------------------------------------------------
prettyConflict :: Conflict -> String
prettyConflict :: Conflict -> String
prettyConflict (Conflict Int
l1 Change
c1 Int
l2 Change
c2) = [String] -> String
unlines
    [ String
"Conflict between edits:"
    , String
"- " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> Change -> String
prettyChange Int
l1 Change
c1
    , String
"- " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> Change -> String
prettyChange Int
l2 Change
c2
    ]


--------------------------------------------------------------------------------
conflicts :: Edits -> [Conflict]
conflicts :: Edits -> [Conflict]
conflicts (Edits Map Int [Change]
edits) = Map Int [Change] -> [(Int, [Change])]
forall k a. Map k a -> [(k, a)]
M.toAscList Map Int [Change]
edits [(Int, [Change])] -> ((Int, [Change]) -> [Conflict]) -> [Conflict]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int -> [Change] -> [Conflict]) -> (Int, [Change]) -> [Conflict]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int -> [Change] -> [Conflict]
checkChanges
  where
    checkChanges :: Int -> [Change] -> [Conflict]
checkChanges Int
_ [] = []
    checkChanges Int
i (CInsert [String]
_ : [Change]
cs) = Int -> [Change] -> [Conflict]
checkChanges Int
i [Change]
cs
    checkChanges Int
i (c1 :: Change
c1@(CBlock Int
_ [String] -> [String]
_) : Change
c2 : [Change]
_) = [Int -> Change -> Int -> Change -> Conflict
Conflict Int
i Change
c1 Int
i Change
c2]
    checkChanges Int
i [c1 :: Change
c1@(CBlock Int
n [String] -> [String]
_)] = do
        Int
i' <- [Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1 .. Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1]
        case Int -> Map Int [Change] -> Maybe [Change]
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Int
i' Map Int [Change]
edits of
            Just (Change
c2 : [Change]
_) -> [Int -> Change -> Int -> Change -> Conflict
Conflict Int
i Change
c1 Int
i' Change
c2]
            Maybe [Change]
_             -> []
    checkChanges Int
i (c1 :: Change
c1@(CLine Int
xstart Int
xend String
_) : c2 :: Change
c2@(CLine Int
ystart Int
_ String
_) : [Change]
cs)
        | Int
xstart Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
ystart = [Int -> Change -> Int -> Change -> Conflict
Conflict Int
i Change
c1 Int
i Change
c2]
        | Int
xend Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
ystart    = [Int -> Change -> Int -> Change -> Conflict
Conflict Int
i Change
c1 Int
i Change
c2]
        | Bool
otherwise        = Int -> [Change] -> [Conflict]
checkChanges Int
i (Change
c2 Change -> [Change] -> [Change]
forall a. a -> [a] -> [a]
: [Change]
cs)
    checkChanges Int
_ (CLine Int
_ Int
_ String
_ : [Change]
_) = []


--------------------------------------------------------------------------------
apply :: Edits -> [String] -> [String]
apply :: Edits -> [String] -> [String]
apply (Edits Map Int [Change]
edits) = case Edits -> [Conflict]
conflicts (Map Int [Change] -> Edits
Edits Map Int [Change]
edits) of
    Conflict
c : [Conflict]
_ -> String -> [String] -> [String]
forall a. HasCallStack => String -> a
error (String -> [String] -> [String]) -> String -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ String
"Language.Haskell.Stylish.Editor: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Conflict -> String
prettyConflict Conflict
c
    [Conflict]
_     -> Int -> [Change] -> [String] -> [String]
go Int
1 (Int -> [Change]
editsFor Int
1)
  where
    editsFor :: Int -> [Change]
editsFor Int
i = [Change] -> Maybe [Change] -> [Change]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [Change] -> [Change]) -> Maybe [Change] -> [Change]
forall a b. (a -> b) -> a -> b
$ Int -> Map Int [Change] -> Maybe [Change]
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Int
i Map Int [Change]
edits

    go :: Int -> [Change] -> [String] -> [String]
go Int
_ [Change]
_ [] = []
    go Int
i [] (String
l : [String]
ls) = String
l String -> [String] -> [String]
forall a. a -> [a] -> [a]
: Int -> [Change] -> [String] -> [String]
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Int -> [Change]
editsFor (Int -> [Change]) -> Int -> [Change]
forall a b. (a -> b) -> a -> b
$ Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) [String]
ls
    go Int
i (CInsert [String]
ls' : [Change]
cs) [String]
ls = [String]
ls' [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ Int -> [Change] -> [String] -> [String]
go Int
i [Change]
cs [String]
ls
    go Int
i (CBlock Int
n [String] -> [String]
f : [Change]
_cs) [String]
ls =
        let ([String]
domain, [String]
ls') = Int -> [String] -> ([String], [String])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
n [String]
ls in
        [String] -> [String]
f [String]
domain [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ Int -> [Change] -> [String] -> [String]
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n) (Int -> [Change]
editsFor (Int -> [Change]) -> Int -> [Change]
forall a b. (a -> b) -> a -> b
$ Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n) [String]
ls'
    go Int
i (CLine Int
xstart Int
xend String
x : [Change]
cs) (String
l : [String]
ls) =
        let l' :: String
l' = Int -> String -> String
forall a. Int -> [a] -> [a]
take (Int
xstart Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) String
l String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
x String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String -> String
forall a. Int -> [a] -> [a]
drop (Int
xend Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) String
l in
        Int -> [Change] -> [String] -> [String]
go Int
i (Int -> Int -> String -> Change -> Change
forall {t :: * -> *} {a}.
Foldable t =>
Int -> Int -> t a -> Change -> Change
adjust Int
xstart Int
xend String
x (Change -> Change) -> [Change] -> [Change]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Change]
cs) (String
l' String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
ls)

    adjust :: Int -> Int -> t a -> Change -> Change
adjust Int
_ Int
_ t a
_ (CInsert [String]
xs) = [String] -> Change
CInsert [String]
xs
    adjust Int
_ Int
_ t a
_ (CBlock Int
n [String] -> [String]
f) = Int -> ([String] -> [String]) -> Change
CBlock Int
n [String] -> [String]
f
    adjust Int
xstart Int
xend t a
x (CLine Int
ystart Int
yend String
y)
        | Int
ystart Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
xend =
            let offset :: Int
offset = t a -> Int
forall a. t a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- (Int
xend Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
xstart) in
            Int -> Int -> String -> Change
CLine (Int
ystart Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offset) (Int
yend Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offset) String
y
        | Bool
otherwise     = Int -> Int -> String -> Change
CLine Int
ystart Int
yend String
y