Compare text

Find the difference between two text files

Real-time editor

Hide unchanged lines

Disable line wrap

Layout

Diff precision

Syntax highlighting

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 11 years agoDiff never expires

41 removals

Lines
Total
Removed

Characters
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

120 lines

26 additions

Lines
Total
Added

Characters
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

104 lines

import Control.Concurrent

import Control.Concurrent.STM

import Control.Concurrent.STM.TVar

import Control.Monad

import System.Directory

import System.Environment (getArgs)

import System.Exit

import System.INotify

import System.IO

import System.Process

data Config =

Config

{ confOutputFile :: FilePath

{ confExecFile :: FilePath

, confCabalFile :: FilePath

, confWorking :: Bool

} deriving (Show,Read)

main = do

args <- getArgs

let dir = head args

let cabalOutput = args !! 1

let execFile = args !! 1

putStrLn $ "Watching directory: " ++ dir

putStrLn $ "Cabal output file: " ++ cabalOutput

putStrLn $ "Exec file: " ++ execFile

contents <- getDirectoryContents dir

fileExists <- doesFileExist execFile

let contents' = filter filterCabal contents

if fileExists

case contents' of

then do

(x:_) -> do

let config = Config execFile False

let config = Config cabalOutput x False

runThread config dir

[] -> do

else do

putStrLn "No cabal file found!"

putStrLn $ "Exec file does not exist!"

putStrLn "Exiting"

runThread config dir = do

config <- newTVarIO config

n <- initINotify

putStrLn "Press <Enter> to exit"

print n

wd <- addWatch n

[ Modify, CloseWrite, Create, Delete, MoveIn, MoveOut ]

dir

(eventHandler config)

print wd

getLine

removeWatch wd

killINotify n

eventHandler :: TVar Config -> Event -> IO ()

eventHandler conf x@(Modified _ (Just fp)) = handleFilteredFile conf x fp

eventHandler conf x@(MovedIn _ fp _) = handleFilteredFile conf x fp

eventHandler conf x@(MovedOut _ fp _) = handleFilteredFile conf x fp

eventHandler conf x@(Created _ fp) = handleFilteredFile conf x fp

eventHandler conf x@(Deleted _ fp) = handleFilteredFile conf x fp

eventHandler _ _ = return ()

handleFilteredFile conf evt fp =

when (filterHS fp) $ print evt >> doWork conf

filterHS fp = fileExt fp == "hs"

filterCabal fp = fileExt fp == "cabal"

fileExt = reverse

. takeWhile (/= '.')

. reverse

doWork :: TVar Config -> IO ()

doWork conf = do

config <- readTVarIO conf

if confWorking config

then do

print "Already working!"

return ()

else do

print "New work available!"

atomically $ writeTVar conf (config { confWorking = True })

_ <- forkIO $ runCI conf

return ()

runCI :: TVar Config -> IO ()

runCI conf = do

runCIChain conf

config <- readTVarIO conf

contents <- readFile $ confExecFile config

execContents $ lines contents

atomically $ writeTVar conf (config { confWorking = False })

return ()

runCIChain :: TVar Config -> IO ()

execContents :: [String] -> IO Bool

runCIChain conf = do

execContents [] = return True

cabalBuild <- runCabal conf ["build"]

execContents (x:xs) = do

print $ "*** cabal build result: " ++ show cabalBuild

let p = shell x

case cabalBuild of

(_,_,_,h) <- createProcess p

False -> return ()

exitCode <- waitForProcess h

True -> do

case exitCode of

cabalTest <- runCabal conf ["test"]

ExitSuccess -> execContents xs

print $ "*** cabal test result: " ++ show cabalTest

runCabal :: TVar Config -> [String] -> IO Bool

runCabal conf args = do

(code, out, err) <- readProcessWithExitCode "cabal" args ""

config <- readTVarIO conf

let outputFile = confOutputFile config

_ <- when (out /= []) $ appendFile outputFile out

_ <- when (err /= []) $ appendFile outputFile err

case code of

ExitSuccess -> return True

ExitFailure _ -> return False

Saved diffs

Original text

Open file

import Control.Concurrent
import Control.Concurrent.STM
import Control.Concurrent.STM.TVar
import Control.Monad
import System.Directory
import System.Environment (getArgs)
import System.Exit
import System.INotify
import System.IO
import System.Process

data Config =
  Config
    { confOutputFile :: FilePath
    , confCabalFile :: FilePath
    , confWorking :: Bool
    } deriving (Show,Read)

main = do
  args <- getArgs
  let dir = head args
  let cabalOutput = args !! 1
  putStrLn $ "Watching directory: " ++ dir
  putStrLn $ "Cabal output file: " ++ cabalOutput
  contents <- getDirectoryContents dir
  let contents' = filter filterCabal contents
  case contents' of
    (x:_) -> do
      let config = Config cabalOutput x False
      runThread config dir
    [] -> do
      putStrLn "No cabal file found!"
      putStrLn "Exiting"

runThread config dir = do
  config <- newTVarIO config
  n <- initINotify
  putStrLn "Press <Enter> to exit"
  print n
  wd <- addWatch n
                 [ Modify, CloseWrite, Create, Delete, MoveIn, MoveOut ]
                 dir
                 (eventHandler config)
  print wd
  getLine
  removeWatch wd
  killINotify n

eventHandler :: TVar Config -> Event -> IO ()
eventHandler conf x@(Modified _ (Just fp)) = handleFilteredFile conf x fp
eventHandler conf x@(MovedIn _ fp _) = handleFilteredFile conf x fp
eventHandler conf x@(MovedOut _ fp _) = handleFilteredFile conf x fp
eventHandler conf x@(Created _ fp) = handleFilteredFile conf x fp
eventHandler conf x@(Deleted _ fp) = handleFilteredFile conf x fp
eventHandler _ _ = return ()

handleFilteredFile conf evt fp =
  when (filterHS fp) $ print evt >> doWork conf

filterHS fp = fileExt fp == "hs"
filterCabal fp = fileExt fp == "cabal"

fileExt = reverse
        . takeWhile (/= '.')
        . reverse

doWork :: TVar Config -> IO ()
doWork conf = do
  config <- readTVarIO conf
  if confWorking config
    then do
      print "Already working!"
      return ()
    else do
      print "New work available!"
      atomically $ writeTVar conf (config { confWorking = True })
      _ <- forkIO $ runCI conf
      return ()

runCI :: TVar Config -> IO ()
runCI conf = do
  runCIChain conf
  config <- readTVarIO conf
  atomically $ writeTVar conf (config { confWorking = False })
  return ()

runCIChain :: TVar Config -> IO ()
runCIChain conf = do
  cabalBuild <- runCabal conf ["build"]
  print $ "*** cabal build result: " ++ show cabalBuild
  case cabalBuild of
    False -> return ()
    True -> do
      cabalTest <- runCabal conf ["test"]
      print $ "*** cabal test result: " ++ show cabalTest

runCabal :: TVar Config -> [String] -> IO Bool
runCabal conf args = do
  (code, out, err) <- readProcessWithExitCode "cabal" args ""
  config <- readTVarIO conf
  let outputFile = confOutputFile config
  _ <- when (out /= []) $ appendFile outputFile out
  _ <- when (err /= []) $ appendFile outputFile err
  case code of
    ExitSuccess -> return True
    ExitFailure _ -> return False

Changed text

Open file

data Config =
  Config
    { confExecFile :: FilePath
    , confWorking :: Bool
    } deriving (Show,Read)

main = do
  args <- getArgs
  let dir = head args
  let execFile = args !! 1
  putStrLn $ "Watching directory: " ++ dir
  putStrLn $ "Exec file: " ++ execFile
  fileExists <- doesFileExist execFile
  if fileExists
    then do
      let config = Config execFile False
      runThread config dir
    else do
      putStrLn $ "Exec file does not exist!"
      putStrLn "Exiting"

handleFilteredFile conf evt fp =
  when (filterHS fp) $ print evt >> doWork conf

filterHS fp = fileExt fp == "hs"

fileExt = reverse
        . takeWhile (/= '.')
        . reverse

runCI :: TVar Config -> IO ()
runCI conf = do
  config <- readTVarIO conf
  contents <- readFile $ confExecFile config
  execContents $ lines contents
  atomically $ writeTVar conf (config { confWorking = False })
  return ()

execContents :: [String] -> IO Bool
execContents [] = return True
execContents (x:xs) = do
  let p = shell x
  (_,_,_,h) <- createProcess p
  exitCode <- waitForProcess h
  case exitCode of
    ExitSuccess -> execContents xs
    ExitFailure _ -> return False