텍스트 비교

두 텍스트 파일의 차이점을 찾아보세요

실시간 편집

변경 없는 행 숨기기

줄바꿈 비활성화

레이아웃

비교 단위

구문 강조

Diffchecker Desktop 가장 안전하게 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