[prev in list] [next in list] [prev in thread] [next in thread] 

List:       darcs-devel
Subject:    [darcs-devel] [patch1602] three patches regarding replace command
From:       Ben Franksen <bugs () darcs ! net>
Date:       2017-09-23 19:41:45
Message-ID: 1506195705.14.0.58435954761.patch1602 () darcs ! net
[Download RAW message or body]

New submission from Ben Franksen <ben.franksen@online.de>:

Look at the patch descriptions for details...

----------
files: re_wrote-token-replace-code.dpatch
messages: 19666
nosy: bf
status: needs-screening
title: three patches regarding replace command

__________________________________
Darcs bug tracker <bugs@darcs.net>
<http://bugs.darcs.net/patch1602>
__________________________________
["re_wrote-token-replace-code.dpatch" (application/x-darcs-patch)]

3 patches for repository http://darcs.net/screened:

patch 5609da31165b937ec58402d1260de1341b412140
Author: Ben Franksen <benjamin.franksen@helmholtz-berlin.de>
Date:   Wed Sep 20 18:21:10 CEST 2017
  * re-wrote token replace code
  
  This is mostly optimization and one bug fix.
  
  The fix is that breakOutToken and therefore breakToTokens can no longer
  return empty tokens. This could happen before and led to crashes (endless
  loop consuming all available memory) when using --look-for-replaces.
  
  The optimization is for forceTokReplace and tryTokReplace. The idea is to
  minimize the number of ByteStrings that we have to re-concat when we are
  done, and so avoid needless copying and allocation. Instead of breaking up
  the input into an alternating list of tokens and non-tokens, we remember the
  original input and a current offset and increase only the offset whenever we
  skip over a non-matching token. In addition, forceTokReplace can use
  Data.ByteString.breakSubstring to efficiently find a match, since we don't
  have to check whether the new token is also found. The two functions can now
  efficiently operate on whole files, so we can avoid breaking (and later
  re-assembling) it into lines inside D.P.Prim.V1.
  

patch 44bfaa60a567615194315e175924e61a93f4a779
Author: Ben Franksen <benjamin.franksen@helmholtz-berlin.de>
Date:   Thu Sep 21 18:20:17 CEST 2017
  * resolve issue2208: replace detects existing force hunks in working
  
  It is wrong to check that we can apply the replace patch to the
  recorded+pending state. This is cared for by addToPending from D.R.State
  which commutes it past the diff between pending and working, pushing
  dependent hunks into pending, too.

patch dcda8f594ca3e4b578b4ae2355c3677e6d7cb006
Author: Ben Franksen <benjamin.franksen@helmholtz-berlin.de>
Date:   Thu Sep 21 18:29:13 CEST 2017
  * fixed error message in replace command
  
  If we cannot apply the replace (plus possible force replace hunks) to
  working then there is something seriously wrong, i.e. this would be a bug.

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256


New patches:

[re-wrote token replace code
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170920162110
 Ignore-this: 97dcc05a73ad999ff8048535df869c1a
 
 This is mostly optimization and one bug fix.
 
 The fix is that breakOutToken and therefore breakToTokens can no longer
 return empty tokens. This could happen before and led to crashes (endless
 loop consuming all available memory) when using --look-for-replaces.
 
 The optimization is for forceTokReplace and tryTokReplace. The idea is to
 minimize the number of ByteStrings that we have to re-concat when we are
 done, and so avoid needless copying and allocation. Instead of breaking up
 the input into an alternating list of tokens and non-tokens, we remember the
 original input and a current offset and increase only the offset whenever we
 skip over a non-matching token. In addition, forceTokReplace can use
 Data.ByteString.breakSubstring to efficiently find a match, since we don't
 have to check whether the new token is also found. The two functions can now
 efficiently operate on whole files, so we can avoid breaking (and later
 re-assembling) it into lines inside D.P.Prim.V1.
 
] hunk ./src/Darcs/Patch/Prim/V1/Apply.hs 19
- -import Darcs.Patch.TokenReplace ( tryTokInternal )
+import Darcs.Patch.TokenReplace ( tryTokReplace )
hunk ./src/Darcs/Patch/Prim/V1/Apply.hs 43
- -    apply (FP f (TokReplace t o n)) = mModifyFilePSs f doreplace
- -        where doreplace ls =
- -                  case mapM (tryTokInternal t (BC.pack o) (BC.pack n)) ls of
+    apply (FP f (TokReplace t o n)) = mModifyFilePS f doreplace
+        where doreplace fc =
+                  case tryTokReplace t (BC.pack o) (BC.pack n) fc of
hunk ./src/Darcs/Patch/Prim/V1/Apply.hs 48
- -                  Just ls' -> return $ map B.concat ls'
+                  Just fc' -> return fc'
hunk ./src/Darcs/Patch/Prim/V1/Commute.hs 16
- -import qualified Data.ByteString as B (ByteString, concat)
- -import qualified Data.ByteString.Char8 as BC (pack)
+import qualified Data.ByteString as B ( ByteString )
+import qualified Data.ByteString.Char8 as BC ( pack )
hunk ./src/Darcs/Patch/Prim/V1/Commute.hs 27
- -import Darcs.Patch.TokenReplace ( tryTokInternal )
+import Darcs.Patch.TokenReplace ( tryTokReplace )
hunk ./src/Darcs/Patch/Prim/V1/Commute.hs 188
- -    case tryTokReplace t o n old1 of
+    let po = BC.pack o; pn = BC.pack n in
+    case tryTokReplaces t po pn old1 of
hunk ./src/Darcs/Patch/Prim/V1/Commute.hs 192
- -      case tryTokReplace t o n new1 of
+      case tryTokReplaces t po pn new1 of
hunk ./src/Darcs/Patch/Prim/V1/Commute.hs 230
- -tryTokReplace :: String -> String -> String
- -                -> [B.ByteString] -> Maybe [B.ByteString]
- -tryTokReplace t o n =
- -  mapM (fmap B.concat . tryTokInternal t (BC.pack o) (BC.pack n))
+tryTokReplaces :: String -> B.ByteString -> B.ByteString
+               -> [B.ByteString] -> Maybe [B.ByteString]
+tryTokReplaces t o n = mapM (tryTokReplace t o n)
hunk ./src/Darcs/Patch/TokenReplace.hs 1
+{-# LANGUAGE CPP #-}
hunk ./src/Darcs/Patch/TokenReplace.hs 3
- -    (
- -      tryTokInternal
+    ( tryTokReplace
hunk ./src/Darcs/Patch/TokenReplace.hs 6
- -    , breakOutToken
hunk ./src/Darcs/Patch/TokenReplace.hs 15
- -import Data.Maybe ( isNothing )
- -
- -import Darcs.Util.ByteString ( substrPS, linesPS, unlinesPS )
+
hunk ./src/Darcs/Patch/TokenReplace.hs 18
- --- | breakOutToken takes a String of token chars and an input ByteString, and
- --- returns the ByteString triple of (beforeToken, token, afterToken).
+#include "impossible.h"
+
+-- | @breakOutToken tokChars input@ splits the @input@ 'ByteString' into
+-- @'Just' (before, token, after)@, where @token@ is the first non-empty
+-- substring consisting only of 'Char's in @tokChars@, or 'Nothing' if no token
+-- was found. The 'Char's in @tokChars@ should not have code points larger than
+-- 255 (0xff).
hunk ./src/Darcs/Patch/TokenReplace.hs 26
- -              -> (BC.ByteString, BC.ByteString, BC.ByteString)
- -breakOutToken tokChars input =
- -    let isTokChar = regChars tokChars
- -        (before, tokAndRest) = BC.break isTokChar input
- -        (tok, remaining) = BC.break (not . isTokChar) tokAndRest in
- -    (before, tok, remaining)
- -
- --- | tryTokInternal takes a String of token chars, an oldToken ByteString, a
- --- newToken ByteString and returns the list of token-delimited ByteStrings,
- --- with any tokens matching oldToken being replaced by newToken. If newToken is
- --- already in the input, we return Nothing.
- -tryTokInternal :: String -> B.ByteString -> B.ByteString -> B.ByteString
- -               -> Maybe [B.ByteString]
- -tryTokInternal _ oldToken newToken input
- -  | isNothing (substrPS oldToken input) &&
- -    isNothing (substrPS newToken input) = Just [ input ]
- -tryTokInternal tokChars oldToken newToken input =
- -    let (before, tok, remaining) = breakOutToken tokChars input in
- -    case tryTokInternal tokChars oldToken newToken remaining of
- -        Nothing -> Nothing
- -        Just rest | tok == oldToken -> Just $ before : newToken : rest
- -                  | tok == newToken -> Nothing
- -                  | otherwise -> Just $ before : tok : rest
- -
- --- | forceTokReplace replaces all occurrences of the old token with the new
- --- token, throughout the input ByteString.
- -forceTokReplace :: String -> B.ByteString -> B.ByteString -> B.ByteString
- -                -> B.ByteString
- -forceTokReplace tokChars oldToken newToken = forceReplaceLines
+              -> Maybe (BC.ByteString, BC.ByteString, BC.ByteString)
+breakOutToken tokChars input
+  | not (B.null tok) = Just (before, tok, remaining)
+  | otherwise = Nothing
hunk ./src/Darcs/Patch/TokenReplace.hs 31
- -    forceReplaceLines = unlinesPS . map forceReplace . linesPS
- -    breakOutAllTokens input | B.null input = []
- -    breakOutAllTokens input =
- -        let (before, tok, remaining) = breakOutToken tokChars input in
- -        before : tok : breakOutAllTokens remaining
- -
- -    forceReplace = B.concat . map replaceMatchingToken . breakOutAllTokens
- -
- -    replaceMatchingToken input | input == oldToken = newToken
- -                               | otherwise = input
- -
+    isTokChar = regChars tokChars
+    (before, tokAndRest) = BC.break isTokChar input
+    (tok, remaining) = BC.break (not . isTokChar) tokAndRest
+
+-- | @tryTokReplace tokChars old new input@ tries to find the token @old@ and
+-- replace it with the token @new@ everywhere in the @input@, returning 'Just'
+-- the modified @input@, unless the token @new@ is already in the @input@ in
+-- which case 'Nothing' is returned. A token is a sequence of bytes that match
+-- the class defined by @tokChars@. This function is supposed to work
+-- efficiently with large @input@s i.e. whole files.
+tryTokReplace :: String -> B.ByteString -> B.ByteString
+              -> B.ByteString -> Maybe B.ByteString
+tryTokReplace tokChars old new
+  | B.null old = bug "tryTokInternal called with empty old token"
+  | BC.any (not . isTokChar) old = bug "tryTokInternal called with old non-token"
+  | BC.any (not . isTokChar) new = bug "tryTokInternal called with new non-token"
+  | otherwise = fmap B.concat . loop 0
+    where
+      isTokChar = regChars tokChars
+      loop !from input =
+        case BC.findIndex isTokChar (B.drop from input) of
+          Nothing -> Just [input]
+          Just start ->
+            case BC.span isTokChar (B.drop (from + start) input) of
+              (tok, rest)
+                | tok == old ->
+                    (B.take (from + start) input :).(new :) <$> loop 0 rest
+                | tok == new -> Nothing
+                | otherwise ->
+                    loop (from + start + B.length tok) input
+
+-- | @forceTokReplace tokChars old new input@ replaces all occurrences of
+-- the @old@ token with the @new@ one, throughout the @input@.
+forceTokReplace :: String -> B.ByteString -> B.ByteString
+                -> B.ByteString -> B.ByteString
+forceTokReplace tokChars old new
+  | B.null old = bug "tryTokInternal called with empty old token"
+  | BC.any (not . isTokChar) old = bug "tryTokInternal called with old non-token"
+  | BC.any (not . isTokChar) new = bug "tryTokInternal called with new non-token"
+  | otherwise = B.concat . loop 0
+    where
+      isTokChar = regChars tokChars
+      len = B.length old
+      loop !from input =
+        case B.breakSubstring old (B.drop from input) of
+          (before, match)
+            | B.null match -> [input] -- not found
+            | B.null before || not (isTokChar (BC.last before))
+            , B.length match == len || not (isTokChar (BC.index match len)) ->
+                -- found and is token
+                B.take (from + B.length before) input : new :
+                  loop 0 (B.drop len match)
+            | otherwise ->
+                -- found but not a token
+                loop (from + B.length before + len) input
+
+-- | Check if a token replace operation touches the given line.
hunk ./src/Darcs/Patch/TokenReplace.hs 89
- -annotateReplace tokChars oldToken newToken input =
- -    let (before, tok, remaining) = breakOutToken tokChars input in
- -    not (B.null before && B.null tok) &&
- -       (tok == oldToken || annotateReplace tokChars oldToken newToken remaining)
- -
- --- break a single bytestring into tokens
+annotateReplace tokChars old new input =
+  case breakOutToken tokChars input of
+    Just (_, tok, remaining) ->
+      (tok == old || annotateReplace tokChars old new remaining)
+    Nothing -> False
+
+-- | Break a 'Bytestring' into tokens, according to 'defaultToks',
+-- discarding non-tokens.
hunk ./src/Darcs/Patch/TokenReplace.hs 98
- -breakToTokens input | B.null input = []
hunk ./src/Darcs/Patch/TokenReplace.hs 99
- -  let (_, tok, remaining) = breakOutToken defaultToks input in
- -    tok : breakToTokens remaining
+  case breakOutToken defaultToks input of
+    Nothing -> []
+    Just (_, tok, remaining) -> tok : breakToTokens remaining

[resolve issue2208: replace detects existing force hunks in working
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170921162017
 Ignore-this: fe088d2c251ecdbbed326944dac5f740
 
 It is wrong to check that we can apply the replace patch to the
 recorded+pending state. This is cared for by addToPending from D.R.State
 which commutes it past the diff between pending and working, pushing
 dependent hunks into pending, too.
] move ./tests/failing-issue2208-replace-fails-with-resolving-unrecorded-change.sh \
./tests/issue2208-replace-fails-with-resolving-unrecorded-change.sh hunk \
                ./src/Darcs/UI/Commands/Replace.hs 57
- -    , readRecordedAndPending
hunk ./src/Darcs/UI/Commands/Replace.hs 179
- -        pending <- readRecordedAndPending repository
hunk ./src/Darcs/UI/Commands/Replace.hs 181
- -            mapM (doReplace toks pending working) files
+            mapM (doReplace toks working) files
+        -- Note: addToPending takes care of commuting the replace patch and
+        -- everything it depends on past the diff between pending and working
hunk ./src/Darcs/UI/Commands/Replace.hs 200
- -              ApplyState prim ~ Tree) => String -> Tree IO -> Tree IO
+              ApplyState prim ~ Tree) => String -> Tree IO
hunk ./src/Darcs/UI/Commands/Replace.hs 202
- -    doReplace toks pend work f = do
- -        let maybeReplace p = isJust <$> maybeApplyToTree replacePatch p
- -        workReplaced <- maybeReplace work
- -        pendReplaced <- maybeReplace pend
- -        if workReplaced && pendReplaced
- -            then return $ joinGap (:>:) (freeGap replacePatch) gapNilFL
- -            else if O.forceReplace ? opts
- -                then getForceReplace f toks work
- -                else putStrLn existsMsg >> return gapNilFL
+    doReplace toks work f = do
+        workReplaced <- maybeApplyToTree replacePatch work
+        case workReplaced of
+          Just _ -> do
+            return $ joinGap (:>:) (freeGap replacePatch) gapNilFL
+          Nothing
+            | O.forceReplace ? opts -> getForceReplace f toks work
+            | otherwise -> putStrLn existsMsg >> return gapNilFL
hunk ./src/Darcs/UI/Commands/Replace.hs 211
- -        existsMsg = "Skipping file '" ++ fp ++ "'\nPerhaps the recorded"
+        existsMsg = "Skipping file '" ++ fp ++ "'\nPerhaps the working"
hunk ./tests/issue2208-replace-fails-with-resolving-unrecorded-change.sh 45
- -# We can get around this by recording, then replacing and amending the patch...
- -darcs rec -am "I don't want to have to record this!"
+cat <<EOF > ../expected
+hunk ./testing 1
+-foo
++baz
+replace ./testing [A-Za-z_0-9] bar foo
+EOF
hunk ./tests/issue2208-replace-fails-with-resolving-unrecorded-change.sh 52
- -darcs replace bar foo testing
+darcs whatsnew > ../actual
hunk ./tests/issue2208-replace-fails-with-resolving-unrecorded-change.sh 54
- -echo y | darcs amend -a
+cd ..
hunk ./tests/issue2208-replace-fails-with-resolving-unrecorded-change.sh 56
- -# Check the workaround succeeded.
- -darcs changes --last 1 -v | grep 'replace.*bar.*foo'
+diff actual expected

[fixed error message in replace command
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170921162913
 Ignore-this: f6d0bea70e7cd0bfb1502cc7629bb83
 
 If we cannot apply the replace (plus possible force replace hunks) to
 working then there is something seriously wrong, i.e. this would be a bug.
] hunk ./src/Darcs/UI/Commands/Replace.hs 186
- -            fail $ "Can't do replace on working!\n"
- -                   ++ "Perhaps one of the files already" ++ " contains '"
- -                   ++ new ++ "'?\n"
- -                   ++ show e
+            bug $ "Can't do replace on working!\n" ++ show e

Context:

[improve efficiency of annotate
Ben Franksen <ben.franksen@online.de>**20170428145539
 Ignore-this: 1c0aa3f5e4e3b970bbaf579263b7a435
 
 The patch index makes finding the relevant patches quite efficient, but when
 a patch contains many hunks, the previous implementation took a very long
 time to finish. This was because it naively applied every hunk and then used
 diff to see which lines were changed.
 
 The new implementation directly observes the effect of patches on the
 Annotated structure using the new Annotate patch interface (type class).
 This also makes attribution of lines to patches more accurate, since the
 result no longer depends on the diff algorithm that annotate used
 internally.
] 
[plugging memory leak in annotate
Ben Franksen <ben.franksen@online.de>**20170427163813
 Ignore-this: 5b62d4833f8586566e5fafa8d572453a
] 
[fixed crash when annotate gets a single invalid filename
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170426162814
 Ignore-this: 730c993b7355eedb8a78ae590c13dad0
] 
[get rid of almost all flag list hacking
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170329210440
 Ignore-this: eb2f438db9a901e51e7e1e73f80499ef
 
 The only command where this was highly non-trivial was whatsnew. For the
 others, a few simple refactorings in the option definitions made the changes
 quite mechanical. For instance, I have changed options where the user code
 (the command implementations, mostly) had to supply a default, with separate
 options (e.g. conficts -> conflictsYes, conflictsNo). This makes it clearer
 which commands have which defaults and makes it less probable to
 accidentally use one default for the options definition and another one for
 parsing the option.
 
 The remaining few cases are those where we need to do processing of the raw
 flag list: the match option hack for init (--to-match is converted to
 --match), and the WorkRepo and NewRepo flags. My plan for removing these is:
 (1) change definition of the matching options darcs init takes, and
 (2) but IO into DarcsOptDescr, so we can do the needed processing on
 options, rather than the raw flag list
] 
[refactor: replace all trivial functions in D.UI.Flags with re-exports
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170328193550
 Ignore-this: e4a09fa82809381af19488194faa7bad
 
 This is a big patch but the changes are mostly trivial. Darcs.UI.Flags
 contained many functions that just extract the value of a primitive option.
 In many cases the functionality was exported under a name that slightly
 differed from the name of the option. All of these functions have been
 removed and replaced with re-exports of options from Dacs.UI.Options.All. In
 some cases the renaming was done in the other direction, i.e. the option was
 renamed to what the function in D...Flags was called.
 
 Re-exporting the options was done because the change is already large enough
 and also for convenience (moving explicitly imported names from one module
 to another for all the many commands is really tedious).
 
 The new (?) operator synonym for parseFlag was used heavily to adapt the
 command implementations.
 
 In a few places I cleaned up legacy code e.g. use putInfo and putVerbose.
] 
[renamed option xmloutput to xmlOutput
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170328133954
 Ignore-this: 4765a2c2cca845048a8f6288b12ee048
] 
[cleaned up pull command
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170328124002
 Ignore-this: 1fe0d978fead28f5fd3c77182d387d4c
 - removed explicit flag list manipulation
 - use verbose, xmlOutput, putVerbose, etc
 - avoid excessively long type signatures for option definitions
] 
[renamed hasXmlOutput to xmlOutput, hasXmlOutput returns Bool
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170328115856
 Ignore-this: 885baeca7863780bbcc1681265690f3e
] 
[rename (amQuiet,amVerbose) to (quiet,verbose), move to D.UI.Flags, and export
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170328114940
 Ignore-this: c7d870eab25ff2394e32dfec6bc44fd9
] 
[refactored shell completion support
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170326210826
 Ignore-this: 140351c8fb04325c4e4f41e7056bf187
 
 - moved listFiles, listRegisteredFiles, listUnregisteredFiles
   from Darcs.Repository to their own module Darcs.UI.Completion
 - renamed them to fileArgs, knownFileArgs, unknownFileArgs
 - added to that module: noArgs and prefArgs
 - import and use these functions for commandGetArgPossibilities
 - renamed this record member to commandCompleteArgs
 - added the full command line info as extra arguments to
   this member, same as for commandCommand
 - re-implemented completion support functions to take difference
   between original cwd and repo path into account
 - incomplete: also take flags and args that are already on the
   command line into account; currently only used for --boring by
   unknownFileArgs; more are planned
 - re-implemented the only remaining (unrelated) use of listFiles in
   Darcs.UI.Command.Util
 - factored expandDirs (which used listFiles) and doesDirectoryReallyExist
   (which is called by expandDirs) from add command to Util
   since it is shared by remove command 
 - use fileArgs for apply and rebase apply instead of noArgs
 - use knownFileArgs for replace command (planned: do this only after the
   two other args have been given)
 - some small things I may have forgotten
] 
[refactored repair/check command
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170323134402
 Ignore-this: ea635b0b788dac9d2b8f21e5b8e61763
 
 - remove explicit manipulations of flag list
 - remove useless dryRun and umask options from check
 - revert check back to a normal (hidden) command but re-use code where
   appropriate
 - make option definitions local to command definitions unless shared between
   commands (avoids type signatures that are useless and detrimental to
   refactorings)
 - cleanup of code layout, including import and export lists
] 
[show repo: fixed excessively borked code indentation
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170323094046
 Ignore-this: 918ea2104ad27711059d09430118efd6
] 
[show repo: removed --files option, removed manual flags parsing
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170323092407
 Ignore-this: f8e1c85a7934aa5158ba32f3ed39c0bf
 
 The --files option was abused to enable additional output of number of
 patches and weak hash. This is completely obscure, since --files gives no
 hint at all as to what effect it has here. The two extra lines are now
 printed unconditionally.
] 
[add patch index status to show repo command
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170319201535
 Ignore-this: 89ee9bebfec64707f2d29f96d061f655
] 
[refactor: add data type for hook options
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170320005236
 Ignore-this: 9e453de94af77090f482aa18ec19beed
 
 This patch is quite simple despite touching many files.
] 
[refactor: move usage and help related functions from Darcs.UI.Commands to \
Darcs.UI.Usage Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170322183559
 Ignore-this: d55631f6578fe3e23cb383213c2b6e63
] 
[refactor: moved printDryRunMessageAndExit from Darcs.UI.Commands to \
Darcs.UI.Commands.Util Ben Franksen \
<benjamin.franksen@helmholtz-berlin.de>**20170322183500  Ignore-this: \
d00a235861f0c1f155b53371eabeb7fa ] 
[refactor: help and usage formatting cleanup
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170322105017
 Ignore-this: 92d8bca3e5c3bfd0214d77e76f601009
 
 The main change here is to use Doc for formatting since it has all the
 features we need and was designed for just that kind of task. This needs the
 recent fix in vsep to avoid too many empty lines in the output.
] 
[remove umask and update_working parameters from withRepoLockCanFail
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170319202004
 Ignore-this: 9fad7aff5a00ba0b8a760a3d36f7e67a
 
 This entry point is currently only used for attemptCreatePatchIndex. I added
 documentation to withRepoLockCanFail that makes it clear that neither
 pending nor pending.tentative should be touched by the job, making the call
 to revertRepositoryChanges unnecessary.
 
 BTW, the passed umask setting was a fake anyway: of both commands
 that use withRepoLockCanFail (log and annotate), none actually has the
 --umask switch (and rightly so, since the user doesn't expect them to write
 any files) so we always get the default NoUMask.
] 
[Fix 'optimize <subcommand> --list-options'
Gian Piero Carrubba <gpiero@rm-rf.it>**20170308120357
 Ignore-this: e69e8e0d23aca84011970cae826ab62d
 erroring out with 'darcs: Prelude.undefined' message
] 
[resolve issue2526: actually consider boring option in D.UI.Flags.diffingOpts
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20170315160845
 Ignore-this: 6c43ca467a60bbe35785b5a4ac4ab9ea
] 
[resolve issue2512: author name is written to repository after multiple-choice prompt
Stephan-A. Posselt <dev-darcs@nimbrium.net>**20161018173325
 Ignore-this: fc7a73a454d35b9b70bc84ee9a924b2c
] 
[added regression test for issue2512
Stephan-A. Posselt <dev-darcs@nimbrium.net>**20161018172504
 Ignore-this: df19775bf8a02796f1aa3e66f42efbd6
] 
[introduce withOldRepoLock, reduce code specific to old-fashioned repos
Guillaume Hoffmann <guillaumh@gmail.com>**20160929213157
 Ignore-this: 6fb77b508088324804d664d79bb83aeb
] 
[rename Darcs.Repository.Internal to Darcs.Repository.Identify
Guillaume Hoffmann <guillaumh@gmail.com>**20160927160123
 Ignore-this: 32c335d198aeb5e6c627140b6a5b8404
] 
[move hashed related functions from Internal to Hashed
Guillaume Hoffmann <guillaumh@gmail.com>**20160927154618
 Ignore-this: f51fe4f258991342f7b9a3f399246cfa
] 
[move repoPatchType from Internal to InternalTypes
Guillaume Hoffmann <guillaumh@gmail.com>**20160926201713
 Ignore-this: b1332e7f77f25e2b64e57e810829fbae
] 
[create Repository.Working
Guillaume Hoffmann <guillaumh@gmail.com>**20160926201137
 Ignore-this: 91b4ec7f4e64e4397a049162e6539e95
] 
[move merge related functions from Internal to Merge
Guillaume Hoffmann <guillaumh@gmail.com>**20160926183320
 Ignore-this: 375e38c09059097fbb788dab225c6abf
] 
[move pending related functions from Internal to Pending
Guillaume Hoffmann <guillaumh@gmail.com>**20160926182908
 Ignore-this: bc9f126db6710ad5e7d8706af945cda7
] 
[rename Darcs.Repository.HashedRepo to Darcs.Repository.Hashed
Guillaume Hoffmann <guillaumh@gmail.com>**20160926154145
 Ignore-this: 1a7fb8f0a4cb85aa8edbc47efb71ca5f
] 
[merge Motd module into Prefs
Guillaume Hoffmann <guillaumh@gmail.com>**20160916215341
 Ignore-this: 9b21ecde946e232720f002e0958e3818
] 
[resolve issue2498: unconditionally use the Haskell HTTP package
Ganesh Sittampalam <ganesh@earth.li>**20160901225222
 Ignore-this: 907b6d2ea2dcc72a2aa5a02d89574ccd
 
 The buildable: False line in the library section was causing problems
 with GHC 8.0 (https://github.com/haskell/cabal/issues/3742), and
 in reality there's no value in being able to turn HTTP off.
 
] 
[resolve issue2496: improve output of darcs whatsnew with file arguments
Ben Franksen <benjamin.franksen@helmholtz-berlin.de>**20160505183910
 Ignore-this: ec14871d3cce595370792f7b52be5f7a
] 
[TAG 2.12.0
Guillaume Hoffmann <guillaumh@gmail.com>**20160429142058
 Ignore-this: 5c8cbe0424942686a2168f9e6fd8e35d
] 
Patch bundle hash:
5e8a59ba44ef22331906b1015238a378b92951d7
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1

iF4EAREIAAYFAlnGuh4ACgkQ025FMW5YzJf8RgD/VARznMT4eiEZNnKxkP68UQ8r
Ckabb02ikrFiBU7GaSgA/3+OKCvu/rqSJczSSntAyUj/z0ys/LaUiCYfcZYtKKbF
=x3r2
-----END PGP SIGNATURE-----



_______________________________________________
darcs-devel mailing list
darcs-devel@osuosl.org
https://lists.osuosl.org/mailman/listinfo/darcs-devel


[prev in list] [next in list] [prev in thread] [next in thread]