比较文本

查找两个文本文件之间的差异

实时编辑器

折叠未更改行

关闭换行

视图

比对精度

语法高亮

Diffchecker Desktop 运行Diffchecker最安全的方式。获取Diffchecker桌面应用：您的差异永远不会离开您的电脑！获取桌面版

Untitled diff

创建于 11年前差异永不过期

41 删除

行
总计
删除

字符
总计
删除

要继续使用此功能，请升级到 Diffchecker Pro 查看价格

120 行

26 添加

行
总计
添加

字符
总计
添加

要继续使用此功能，请升级到 Diffchecker Pro 查看价格

104 行

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

已保存差异

原始文本

打开文件

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

更改后文本

打开文件

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