-- | An Editor backend implementation, made of the instance of Engine of InsideAppend.
+moduleBuffer(InsideAppend(..))
+where
+
+importData.Maybe
+importEngine
+importTest.QuickCheck
+
+-- |See the "Engine" class docs
+dataInsideAppend
+-- | the cursor when its pointing to a real line (eg line function doesn't fail)
+=Inside{
+left::[String],-- ^ lines before the cursor (reversed order)
+cursor::String,-- ^ addressed line
+right::[String]-- ^ lines after the cursor
+}
+-- | the cursor is pointing either to insert at the front of the file or
+-- append at the end of the file.
+|Append
+{
+elems::Either[String][String]-- ^ Left lines is in append mode, Right is in insert at front mode.
+}
+deriving(Show,Eq)
+
+instanceEngineInsideAppendwhere
+listInxs=Append(Rightxs)
+prev(Append(Right_))=Nothing
+prev(Append(Left[]))=error"empty Append Left"
+prev(Append(Left(l:ls)))=Just$Insidelsl[]
+prev(Inside[]xls)=Just$Append(Right(x:ls))
+prev(Inside(l:ls)xrs)=Just$Insidelsl(x:rs)
+next(Append(Right[]))=Nothing
+next(Append(Right(r:rs)))=Just$Inside[]rrs
+next(Append(Left[]))=error"empty Append Left"
+next(Append(Left_))=Nothing
+next(Insidelsx[])=Just$Append(Left(x:ls))
+next(Insidelsx(r:rs))=Just$Inside(x:ls)rrs
+endw@(Append(Left_))=Justw
+endw=nextw>>=end
+startw@(Append(Right_))=Justw
+startw=prevw>>=start
+pos(Append(Leftls))=End(lengthls+1)
+pos(Append(Right_))=Begin
+pos(Insidels__)=Line$lengthls+1
+del(Append_)=Nothing
+del(Inside[]_[])=Just$Append(Right[])
+del(Insidels_[])=Just$Append(Leftls)
+del(Insidels_(r:rs))=Just$Insidelsrrs
+delnnw|n==0=Justw
+|True=delw>>=deln(n-1)
+addxs(Append(Left_))=Nothing
+addxs(Append(Rightrs))=Just$Append$Right(xs++rs)
+addxs(Insidelsxrs)=Just$Insidelsx(xs++rs)
+insxsw=prevw>>=addxs>>=next
+jumpnw=startw>>=rjumpn
+listOutw=startw>>=\(Append(Rightrs))->returnrs
+linen0_=Just[]
+linen_(Append_)=Nothing
+linennw@(Inside_x_)=nextw>>=linen(n-1)>>=Just.(x:)
+
+tillendw=filterisInside(runnernextw)
+
+fromstartw=reverse$filterisInside(runnerprevw)
+
+fwdcyclew=filterisInside$runnernextw++reverse(runnerprevw)++[w]
+bwdcyclew=filterisInside$runnerprevw++reverse(runnernextw)++[w]
+
+isInside::InsideAppend->Bool
+isInside(Inside___)=True
+isInside_=False
+
+runner::ChangeInsideAppend->InsideAppend->[InsideAppend]
+runneropw=maybe[](\w->(w:runneropw))(opw)
+
+prop_E1_IA=prop_E1::(WInsideAppend)->String->Bool
+--prop_Empty_IA = prop_Empty ::
+t=listIn["paolo","va","in","bici"]::InsideAppend
+
{-# LANGUAGE MultiParamTypeClasses,NoMonomorphismRestriction,FlexibleContexts,FlexibleInstances,UndecidableInstances #-}
+
+-- | Main datas and types for the editor
+moduleEditor
+where
+
+importControl.Monad.State
+importControl.Monad.Reader
+importControl.Monad.Error
+
+importUndo
+importEngine
+
+
+-- | Stato is parametrized on an Engine instance and hold the engine with the last regex entered , regex G and g are not implemented now
+dataStatow=Stato{
+file::w,-- ^ data holding the file
+lastre::String,-- ^ a regex
+filename::MaybeString,-- ^ the file we are editing
+pending::MaybeCommand,-- ^ a sensible state for data lost
+lastsaved::Maybew
+}deriving(Show,Eq)
+
+-- | the core editor runs under the state monad with state (Stato w) .
+-- Wrapped around a monad (IO mainly) to permit console input and output of commands with IO
+-- and testing with State
+typeStatoEmw=UndoT(Statow)m
+
+liftStatoE::Ctxmw=>StatoEmwa->Editormwa
+liftStatoE=lift
+
+-- | push a new file (data 'Engine' instance) in the core State, pushing the old state in the undo stack
+hputfile::Ctxmw=>w->Editormw()
+hputfilex=get>>=\y->liftStatoE$hputy{file=x}
+
+putfilex=get>>=\y->puty{file=x}
+putlastrex=get>>=\y->puty{lastre=x}
+setfilenamex=get>>=\y->puty{filename=x}
+setpendingx=get>>=\y->puty{pending=x}
+setlastsaved=get>>=\y->puty{lastsaved=Just(filey)}
+unsetlastsaved=get>>=\y->puty{lastsaved=Nothing}
+
+
+
+
+-- | placeholder for the two constraints
+class(Enginew,SIOm,HCtxm(Statow))=>Ctxmw
+instance(Enginew,SIOm,HCtxm(Statow))=>Ctxmw
+
+-- | the errors (monad failers) which can break the monad flow
+dataErr
+=StopErr-- ^ issued on ctrl-d or q command (q not implemented)
+|ParserErrString-- ^ command line was not parsed to a CompleteCommand
+|RegexUnmatched-- ^ the regex doesn't match a line
+|EvalErrErr-- ^ something bad happened in the evaluation process
+|BackendErr-- ^ lines were addressed out of file (see 'Engine')
+|AhiString-- ^ uncontrolled errors
+|FileReadErrString-- ^ io error trying to load a file
+|FileNameMissing-- ^ filename is not set
+|FileWriteErrString-- ^ io error trying to write the file
+|ExternalCommandErrString-- ^ io error executing an external program
+|PendingStateCommand-- ^ a sensible data discarding command has been entered
+|NoMoreUndo-- ^ reached the first state remembered
+|NoMoreRedo-- ^ reached the last state remembered
+|CommandHelpMissing-- ^ a help for a missing command was asked
+|CommandHelpParseErrString-- ^ error parsing the help for commands
+derivingShow
+
+instanceErrorErrwhere
+noMsg=Ahi"nomsg"
+strMsg=Ahi
+
+-- | a layer for IO simulation, see "Main" for the real program one and "Test" for tests
+class(Monadm)=>SIOmwhere
+-- | accepts a prompt and should return Nothing on eof else a line of input
+inputSio::String->m(MaybeString)
+outputSio::String->m()-- ^ output a normal string
+historySio::String->m()-- ^ put a line in the history (which is global)
+errorSIO::String->m()-- ^ output an error string
+readfileSio::String->ErrorTStringmString-- ^ read a file
+writefileSio::String->String->ErrorTStringm()-- ^ write a file
+-- | runs an external command , first arg is the command
+-- the output is returned or an error is signalled in the errort monad
+externalSio::String->ErrorTStringmString
+-- the path for the command help file
+commandhelpSIO::mFilePath
+
+liftSio::Ctxmw=>ma->Editormwa
+liftSio=lift.lift
+
+-- | commands for the editor
+dataCommand
+-- | get some text and add it after the addressed line
+=Append
+-- | get some text and add it before the addressed line
+|Insert
+-- | get some text and add it in place of some deleted lines
+|Change
+-- | delete some lines
+|Delete
+-- | print some lines
+|Print
+-- | get some commands and execute them on each line matching a regex
+|SmallGString-- not implemented
+-- | interactively execute commands on each line matching a regex
+|BigGString-- not implemented
+-- | Change the addressed line
+|NoCommand
+-- | Load a file
+|EditString
+-- | Write the file
+|Write
+-- | Write a new file
+|WriteNewString
+-- | Set filename
+|SetFilenameString
+-- | Print filename
+|GetFilename
+-- | Load the output of an external command
+|EditExternalString
+-- | Revert the last change if ever
+|UndoChange
+-- | Restore via the last change
+|RedoChange
+-- | Asking help
+|HelpList
+-- | Spedific help
+|HelpTopicString
+deriving(Show,Eq)
+
+
+-- | represents a line position in the file
+dataOffset
+-- | beyond last line, the append line
+=LastLine
+-- | the nth line
+|AbsoluteInt
+-- | the line addressed by the engine
+|Current
+-- | the nth line before the addressed one
+|PrevInt
+-- | the nth line aftor the addressed one
+|NextInt
+-- | the next line (wrapping around) matching a regex
+|ReNextString
+-- | the next line matching the last learned regex
+|LastReNext
+-- | the previous line (wrapping around) matching a regex
+|RePrevString
+-- | the previous matching the last learned regex
+|LastRePrev
+-- | the line marked previously with a char
+|MarkedAsCharderivingShow
+-- | a couple of Offsets
+dataRange=RangeOffsetOffsetderivingShow
+
+-- | wrapper a round the two possible addressing for a command Offset and Range
+dataOffsetOrRange
+=OROOffset
+|ORRRange
+|ORNderivingShow
+
+-- | a complete command is a Command coupled with a Range or an Offset
+dataCompleteCommand=CCCommandOffsetOrRangederivingShow
+
+
+-- | main datatype for the program-- beyond the core state, a simulation layer 'SIO' can be read
+-- and errors 'Err' can be thrown to kill the monad flow
+typeEditormw=ErrorTErr(StatoEmw)
+
+
+-- | wrap a maybe action and throw a backend error on a Nothing
+backend::Ctxmw
+=>Maybea-- ^ maybe action
+->Editormwa-- ^ monading
+backend=maybe(throwErrorBackendErr)return
+
+-- | execute an action on the file
+through::Ctxmw
+=>(w->Maybea)-- ^ an action from an engine w to a maybe
+->Editormwa-- ^ the result from Just in the Editor monad
+throughf=getsfile>>=backend.f
+
+
+-- | the inputSio action lifted to Editor
+pinput::Ctxmw=>String->Editormw(MaybeString)
+pinput=liftSio.inputSio
+
+-- | the inputSio action lifted to Editor with empty prompt
+input::Ctxmw=>Editormw(MaybeString)
+input=pinput""
+
+-- | the outputSio action lifted to Editor
+output::Ctxmw=>String->Editormw()
+output=liftSio.outputSio
+
+-- | the historySIO action lifted to Editor
+history::Ctxmw=>String->Editormw()
+history=liftSio.historySio
+
+-- | the errorSIO action lifted to Editor
+errorlog::Ctxmw=>String->Editormw()
+errorlog=liftSio.errorSIO
+
+-- | editor runner .
+-- resolve the all monad from a core state to another
+run::Ctxmw
+=>Editormwa-- ^ the action to run
+->Statow-- ^ the initial state
+->m(Statow)-- ^ the final state wrapped in the monad choosen for the SIO
+
+runeditorw=flipexecUndoTw$runErrorTeditor>>=\x->
+casexofLefterr->lift$errorSIO(showerr)
+Right_->return()
+
+
-- | Abstraction on a "zipped" list. Use these instances to have a list cursored on a position, also
+-- called double linked list.
+moduleEnginewhere
+
+importTest.QuickCheck
+importControl.Monad
+importData.Maybe
+importData.List
+
+-- | represent an action, which can fail with Nothing , an index error
+typeChangea=a->Maybea
+
+-- | Pos represent the position addressed in the engine
+dataPos
+-- | the engine addresses a real line
+=Line{
+nth::Int-- ^ The index of the line starting from 1
+}
+-- | the engine addresses before first line , if ever present
+|Begin
+-- | the engine addresses after last line
+|End{
+lns::Int-- ^ The number of lines in the engine
+}
+derivingShow
+-- | relative distance between two positions
+distance(Linen)(Linem)=m-n+1
+distanceBegin(Linem)=m
+distance(Linen)(Endm)=m-n
+distanceBegin(Endm)=m
+distance__=0
+
+-- | the class to implement for holding a list of elements with a cursor on them
+classEqa=>Engineawhere
+
+-- | An empty engine
+empty::a
+empty=listIn[]
+-- | An engine is isomorphic to a list
+listIn::[String]->a
+-- | Extract the list from the engine
+listOut::a->Maybe[String]
+-- | Extract n lines from the position addressed
+linen::Int->a->Maybe[String]
+-- | Extract the addressed line
+line::a->MaybeString
+linew=head`fmap`linen1w
+-- | Possibly set the addressed line to the nth line
+jump::Int->Changea
+-- | Insert some lines before the addressed line
+ins::[String]->Changea
+-- | Insert some lines after the addressed line
+add::[String]->Changea
+-- | Delete the addressed line , address the next one
+del::Changea
+-- | Delete n lines from the addressed position
+deln::Int->Changea
+-- | Address an append position
+end::Changea
+-- | Address before the first line
+start::Changea
+-- | The number of the addressed line
+pos::a->Pos
+-- | Address the next line
+next::Changea
+-- | Address the prev line
+prev::Changea
+-- | Jump back n lines
+prevn::Int->Changea
+prevn0w=Justw
+prevnnw=prevw>>=prevn(n-1)
+-- | Jump ahead n lines
+nextn::Int->Changea
+nextn0w=Justw
+nextnnw=nextw>>=nextn(n-1)
+-- | Jump n lines relative to the addredded line
+rjump::Int->Changea
+rjumpn=iterateMn(ifn>0thennextelseprev)where
+iterateMnfw|n>0=fw>>=iterateM(n-1)f
+|True=Justw
+-- | Create all the engines from the addressed one to the last one
+tillend::a->[a]
+-- | all the next engines from the addressed next to itself , wrapping around
+fwdcycle::a->[a]
+-- | Create all the engines from the start to the addressed one included
+fromstart::a->[a]
+-- | all the prev engines from the addressed prev to itself , wrapping around
+bwdcycle::a->[a]
+
+-- | last element if present
+last::Enginew=>Changew
+lastt=endt>>=prev
+-- | first element if present
+first::Enginew=>Changew
+firstt=startt>>=next
+
+newtypeWw=WwderivingShow
+instance(Eqw,Enginew)=>Arbitrary(Ww)where
+arbitrary=don<-choose(0,10)
+ws<-replicateMn$replicateM15$choose('a','z')
+return$W$listInws
+coarbitrary=undefined
+instanceArbitraryCharwhere
+arbitrary=choose('a','z')
+coarbitrary=undefined
+
+
+
+
+prop_E1::(Enginew)=>Ww->String->Bool
+prop_E1(Wy)=\x->(add[x]y>>=listOut)==Just(x:fromJust(listOuty))
+
+propInOutfxs=Just$listInxs>>=f>>=listOut
+prop_Empty(Wy)=(y==empty)==>prevy==Nothing&&nexty==Nothing
+prop_toEnd(Wy)=(y/=empty)==>letJustls=length`fmap`listOuty
+incollectls$nextn(ls+1)y==endy&&nextnlsy==(endy>>=prev)
+prop_toEndAndBack(Wy)=(y/=empty)==>letJustls=length`fmap`listOuty
+incollectls$(endy>>=start)==Justy
+prop_add(Wy)xs=(addxsy>>=listOut)==Justxs
+--prop_ins (W y) xs = (listIn xs >>= end >>= ins xs >>= listOut) == Just (head xs:head
+--
+-- data Prop w = forall p . (Engine w) => Prop w (\w -> \p -> Property)
+
-- | The logic of each of the available commands
+moduleEvalwhere
+
+importSystem.IO
+importControl.Monad.Trans
+importControl.Monad.Reader
+importControl.Monad.State
+importControl.Monad.Error
+importEditor
+importOperation
+importOffset
+importUndo
+importHelper
+importEngine
+
+
+-- | every command is run with eval. See 'Editor.Command' datatype for docs
+eval::Ctxmw
+=>CompleteCommand-- ^ the command to match for execution
+->Editormw()-- ^ monading ..
+
+
+eval(CCAppend(OROo))=inputMode>>=editOffseto.add
+eval(CCInsert(OROo))=inputMode>>=editOffseto.ins
+eval(CCDelete(OROo))=editOffsetodel
+eval(CCDelete(ORRr))=editRangerdeln
+eval(CCChange(OROo))=do
+w<-jumpEo
+(l,u)<-backend$linew>>=\l->delw>>=\u->return(l,u)
+historyl>>inputMode>>=backend.flipinsu>>=putfile
+
+eval(CCChange(ORRr))=do
+(n,w)<-rangeResolver
+u<-backend$delnnw
+inputMode>>=backend.flipinsu>>=putfile
+
+eval(CCPrint(OROo))=doOffsetooutputline
+eval(CCPrint(ORRr))=doRanger(mapM_output)linen
+eval(CCNoCommand(OROo))=jumpEo>>=\w->backend(linew)>>=output>>putfilew
+eval(CCNoCommandORN)=jumpE(Next1)>>=\w->backend(linew)>>=output>>putfilew
+eval(CCNoCommand(ORR(Rangeo1o2)))=jumpEo2>>=putfile
+
+eval(CCc@(Edite)_)=evalSensiblec$
+liftSio(runErrorT$readfileSioe)>>=
+either(throwError.FileReadErr)(putfile.listIn.lines)>>
+setfilename(Juste)>>setlastsaved
+eval(CCWrite_)=getname(throwErrorFileNameMissing)>>=write>>unsetlastsaved
+
+eval(CC(WriteNewnname)_)=getname(returnnname)>>=\name->writenname>>
+setfilename(Justname)>>setlastsaved
+eval(CCGetFilename_)=getname(throwErrorFileNameMissing)>>=output
+eval(CCc@(SetFilenames)_)=getsfilename>>=flip(maybeid(const$evalSensiblec))
+(setfilename(Justs)>>unsetlastsaved)
+eval(CCc@(EditExternals)_)=evalSensiblec$
+liftSio(runErrorT$externalSios)>>=
+either(throwError.ExternalCommandErr)(putfile.listIn.lines)>>
+unsetlastsaved
+eval(CCUndoChange_)=liftStatoEundo>>=bool(return())(throwErrorNoMoreUndo)
+eval(CCRedoChange_)=liftStatoEredo>>=bool(return())(throwErrorNoMoreRedo)
+eval(CCHelpList_)=liftSio(runErrorT$readfileSio"command.help")>>=
+either(throwError.FileReadErr)(return.listOfCommands)>>=
+either(throwError.CommandHelpParseErr)(maybe(throwError$Ahi"Boh")output)
+eval(CC(HelpTopict)_)=liftSio(runErrorT$readfileSio"command.help")>>=
+either(throwError.FileReadErr)(return.helpCommandt)>>=
+either(throwError.CommandHelpParseErr)(maybe(throwErrorCommandHelpMissing)output)
+
+boolxyb=ifbthenxelsey
+
+-- | throw a 'writerSio' error to Editor
+writefail::Ctxmw=>EitherString()->Editormw()
+writefail=either(throwError.FileWriteErr)return
+
+-- | dump the engine content to a file via writefileSio
+write::Ctxmw
+=>String-- ^ filename
+->Editormw()-- ^ monading
+writename=do
+contents<-unlines`fmap`throughlistOut
+(liftSio.runErrorT)(writefileSionamecontents)>>=writefail
+setlastsaved
+-- | get the filename defaulting to some other action to produce one
+getname::Ctxmw=>EditormwString->EditormwString
+getnamedefaul=getsfilename>>=maybedefaulreturn
+
{-# LANGUAGE ParallelListComp #-}
+-- | Parse and pretty print the string of help of commands
+moduleHelperwhere
+importControl.Monad
+importText.ParserCombinators.Parsec.Prim
+importText.ParserCombinators.Parsec.Char
+importText.ParserCombinators.Parsec.Token
+importText.ParserCombinators.Parsec.Combinator
+importText.PrettyPrint(render,text,nest,(<>),(<+>),($$),sep)
+importData.List(transpose,find)
+
+
+-- |structure for the help of a command
+dataCommandHelp=CommandHelp{
+name::String,-- ^ the command name
+synopsis::String,-- ^ how to run it
+descriptions::[String],-- ^ aspects
+errors::[String],-- ^ errors explanations
+implementation::String-- ^ implementation state
+}
+
+instanceShowCommandHelpwhere
+show(CommandHelpnamesynopsisdescriptionserrorsimplementation)=render$
+text("Command: "++name)$$
+nest4(
+text("Synopsis: "++synopsis)$$
+(text("Description: ")<>foldr1($$)(maptextdescriptions))$$
+(text("Errors: ")<>foldr1($$)(maptexterrors))$$
+text("Implementation: "++implementation)
+)
+-- |parses a CommandHelp
+parseACommandHelp::CharParser()CommandHelp
+parseACommandHelp=do
+name<-field0"command"
+synopsis<-field1"synopsis"
+descriptions<-many(try$field1"description")
+errors<-many(try$field1"error")
+implementation<-field1"implementation"
+return$CommandHelpnamesynopsisdescriptionserrorsimplementation
+where
+fieldnname=replicateMntab>>stringname>>char')'>>manyspace>>manyTillanyCharnewline
+
+-- |parses all commands help
+parseCommandsHelp::CharParser()[CommandHelp]
+parseCommandsHelp=do
+rs<-many(try$manyemptyline>>parseACommandHelp)
+manyTillanyChareof
+returnrs
+where
+emptyline=manyTillspacenewline
+
+-- |run the parser against a string
+run
+::String-- ^ The string to parse
+->GenParserChar()a-- ^ the parser to use
+->(a->Maybeb)-- ^ a function to use on the result , if it succed
+->EitherString(Maybeb)-- ^ the error showed if it fails or the result closed
+
+runfilepcl=either(Left.show)(Right.cl)(parsep"help parser"file)
+
+-- |create a nice table from lines of words
+tabulate::[[String]]->String
+tabulate=render.foldr1($$).tabulate'.transposewhere
+tabulate'(xs:[])=maptextxs
+tabulate'(xs:yss)=[textx$$nest(maximum(maplengthxs)+1)y|x<-xs|y<-tabulate'yss]
+
+-- |parse a prettyprint of a list of command helps from a string
+listOfCommands
+::String-- ^ the string with the help inside
+->EitherString(MaybeString)-- ^ a parse error or Just a prettyprint of a list of command helps
+listOfCommandsfile=runfileparseCommandsHelp(Just.tabulate.map(\c->[synopsisc,namec]))
+
+-- |parse a prettyprint of a list of command helps from a string
+helpCommand
+::String-- ^ the command name
+->String-- ^ the string with the help inside
+->EitherString(MaybeString)-- ^ a parse error or (Just the command help or Nothing if the command is missing)
+helpCommandsfile=runfileparseCommandsHelp(\xs->find((==s).name)xs>>=return.show)
+
-- | Operations involving Offset and Range through Engine interface
+moduleOffsetwhere
+importText.Regex.Posix
+importData.List(find)
+importData.Maybe(fromJust)
+importControl.Monad.State
+importEditor
+importEngine
+
+-- | move the cursor in the engine
+jumpE::Ctxmw
+=>Offset-- ^ the new position for the cursor
+->Editormww-- ^ the modified engine under the Editor
+
+jumpECurrent=throughJust
+jumpELastLine=throughEngine.last
+jumpE(Nextn)=through$nextnn
+jumpE(Prevn)=through$prevnn
+jumpE(Absoluten)=through$jumpn
+jumpE(ReNexts)=putlastres>>(through.finderfwdcycle)s
+jumpELastReNext=getslastre>>=through.finderfwdcycle
+jumpE(RePrevs)=putlastres>>(through.finderbwdcycle)s
+jumpELastRePrev=getslastre>>=through.finderbwdcycle
+
+
+finderfs=find((=~s).fromJust.line).f
+
+-- | From a range to the tuple (nelements,starting range element)
+rangeResolve::Ctxmw
+=>Range-- ^ the range to focus
+->Editormw(Int,w)-- ^ the tuple (nelements,engine placed
+-- at first offset of range)
+rangeResolve(Rangeo1o2)=do
+w1<-jumpEo1
+w2<-jumpEo2
+return(distance(posw1)(posw2),w1)
+
+-- | a complete backend + Editor action on an Offset
+doOffset::Ctxmw
+=>Offset-- ^ Offset for the action
+->(a->Editormwb)-- ^ the final action
+->(w->Maybea)-- ^ the backend ation
+->Editormwb-- ^ ..
+doOffsetoefmf=jumpEo>>=backend.mf>>=ef
+
+-- | a backend action ending in a save state for the file
+editOffset::Ctxmw
+=>Offset-- ^ Offset for the backend action
+->(w->Maybew)-- ^ the backend ation
+->Editormw()-- ^ modified monad
+editOffseto=doOffsetohputfile
+
+-- | a complete backend + Editor action on a Range
+doRange::Ctxmw
+=>Range-- ^ the addressed range
+->(a->Editormwb)-- ^ the closing Editor action
+->(Int->w->Maybea)-- ^ the backend action
+->Editormwb-- ^ ...
+doRangerefmf=rangeResolver>>=backend.uncurrymf>>=ef
+
+editRange::Ctxmw
+=>Range-- ^ the addressed range
+->(Int->w->Maybew)-- ^ the backend action
+->Editormw()-- ^ modified monad
+editRanger=doRangerhputfile
+
+
+
-- | Functions for read-eval-do managing
+moduleOperationwhere
+
+importControl.Monad.State
+importControl.Monad.Error
+
+importEditor
+importEngine
+importOffset
+
+-- | a real check for file modification
+modified::Ctxmw=>EditormwBool
+modified=do
+lastw<-getslastsaved
+now<-getsfile
+return$maybeTrue(==now)lastw
+
+resetpending::Ctxmw=>Editormw()
+resetpending=setpendingNothing
+
+-- | a wrapper for commands evaluation which can discard changes
+evalSensible::Ctxmw=>Command->Editormw()->Editormw()
+evalSensiblecaction=do
+mod<-modified
+ifmodthen
+letonunpending=setpending(Justc)>>errorlog(show$PendingStatec)
+onpendingx=ifx==cthenaction>>resetpending
+elseonunpending
+ingetspending>>=maybeonunpendingonpending
+elseaction>>resetpending
+
+-- | a wrapper for commands evaluation which cannot discard changes
+checkPendings::Ctxmw=>Editormw()->Editormw()
+checkPendingsaction=do
+pends<-getspending
+action
+newpends<-getspending
+when(newpends==pends)resetpending
+
+
+-- | a step in main mode for the editor
+commandMode::Ctxmw
+=>(String->EitherStringCompleteCommand)-- ^ the parser for the command on the line
+->(CompleteCommand->Editormw())-- ^ the evaluator for the parsed command
+->Editormw()-- ^ updated beast
+commandModeparseeval=let
+parsevalline=either(throwError.ParserErr)
+((historyline>>).checkPendings.eval)
+(parseline)
+prompt=do
+p<-gets$pos.file
+pinput$casepof
+Begin->"0 > "
+Linep->showp++" > "
+End_->"$ > "
+inprompt>>=maybe(throwErrorStopErr)parseval
+
+-- | looping in main mode with error log on output
+commandLoop::Ctxmw
+=>(String->EitherStringCompleteCommand)-- ^ the parser for the command on the line
+->(CompleteCommand->Editormw())-- ^ the evaluator for the parsed command
+->Editormw()-- ^ updated beast
+
+commandLoopparseeval=let
+reactionStopErr=errorlog"End">>returnFalse
+reaction(Ahix)=errorlog("Unhandled exception: "++x)>>returnFalse
+reactionBackendErr=errorlog"Buffer index error">>returnTrue
+reaction(ParserErrs)=errorlog("Parser error: "++s)>>returnTrue
+reactionerr=errorlog("Evaluation error: "++showerr)>>returnTrue
+indorun<-catchError(commandModeparseeval>>returnTrue)reaction
+ifrunthencommandLoopparseevalelsereturn()
+
+-- | the secondary mode for the editor where lines are inserted as input. It returns the lines.Use CTRL-D to exit
+inputMode::Ctxmw=>Editormw[String]
+inputMode=input>>=maybe(return[])aline
+wherealinejl=inputMode>>=return.(jl:)
+
moduleParser
+where
+
+importText.ParserCombinators.Parsec.Token
+importText.ParserCombinators.Parsec
+importText.ParserCombinators.Parsec.Language
+importText.ParserCombinators.Parsec.Error
+
+importEditor
+importOffset
+
+
+-- | shortcut for a parser of chars with no state
+typeParseE=GenParserChar()
+
+-- | parse an integer number
+numero::ParseEInteger
+numero=naturalhaskell
+
+parseFilename=manyTillanyChar((many1space>>return())<|>eof)
+parseExternalCommand=char'!'>>manyTillanyChareof
+parseCommandName=parseFilename
+
+-- | parse an Offset
+parseOffset::ParseEOffset
+parseOffset=let
+lastline=char'$'>>returnLastLine
+absolute=numero>>=return.Absolute.fromInteger
+current=char'.'>>returnCurrent
+previous1=char'-'>>numero>>=return.Prev.fromInteger
+previous2=many1(char'-')>>=return.Prev.length
+next1=(space<|>char'+')>>numero>>=return.Next.fromInteger
+next2=many1(char'+')>>=return.Next.length
+arec=charc>>manyTillanyChar((charc>>return())<|>eof)
+renext=are'/'>>=return.ReNext
+lastrenext=string"//">>returnLastReNext
+reprev=are'?'>>=return.RePrev
+lastreprev=string"??">>returnLastRePrev
+markedas=string"'">>lower>>=return.MarkedAs
+inchoice(maptry[lastline,absolute,current,previous1,previous2,next1,next2,
+lastrenext,renext,lastreprev,reprev,markedas])
+
+-- | parse a Range
+parseRange::ParseERange
+parseRange=let
+couple=do
+l<-parseOffset
+char','
+r<-parseOffset
+return$Rangelr
+coma=char','>>return(Range(Absolute1)LastLine)
+semicoma=char';'>>return(RangeCurrentLastLine)
+inchoice(maptry[coma,semicoma,couple])
+
+-- | defaults Offset or Range for the commands
+defaultOR::Command->OffsetOrRange
+defaultORAppend=OROCurrent
+defaultORInsert=OROCurrent
+defaultORChange=OROCurrent
+defaultORPrint=OROCurrent
+defaultOR(SmallG_)=ORR(Range(Absolute1)(Current))
+defaultOR(BigG_)=ORR(Range(Absolute1)(Current))
+defaultORDelete=OROCurrent
+defaultORNoCommand=ORN
+defaultOR(Edit_)=ORN
+defaultORWrite=ORN
+defaultOR(WriteNew_)=ORN
+defaultOR(SetFilename_)=ORN
+defaultORGetFilename=ORN
+defaultOR(EditExternals)=ORN
+defaultORUndoChange=ORN
+defaultORRedoChange=ORN
+
+-- | forces a failure for a command if a Range was parsed
+acceptOffsetOnly::Command->OffsetOrRange->ParseE()
+acceptOffsetOnlyc(ORR_)=pzero<?>("only offsets for function "++showc++".")
+acceptOffsetOnly__=return()
+
+-- | parse an OffsetOrRange
+parseOffsetOrRange::ParseEOffsetOrRange
+parseOffsetOrRange
+=try(parseRange>>=return.ORR)
+<|>try(parseOffset>>=return.ORO)
+<|>returnORN
+
+-- | helper for skipping a filter
+rconst::Command->ParseE(OffsetOrRange->ParseECommand)
+rconst=return.const.return
+
+-- | parse a function from OffsetOrRange to a parse Command
+parseCommand::ParseE(OffsetOrRange->ParseECommand)
+parseCommand=let
+append=char'a'>>eof>>return(\r->acceptOffsetOnlyAppendr>>returnAppend)
+insert=char'i'>>eof>>return(\r->acceptOffsetOnlyInsertr>>returnInsert)
+change=char'c'>>eof>>rconstChange
+delete=char'd'>>eof>>rconstDelete
+print=char'p'>>eof>>rconstPrint
+smallg=char'g'>>char'/'>>many1(noneOf"/")
+>>=\p->char'/'>>eof>>rconst(SmallGp)
+bigg=char'G'>>char'/'>>many1(noneOf"/")
+>>=\p->char'/'>>eof>>rconst(BigGp)
+nocomm=eof>>rconstNoCommand
+extedit=char'e'>>many1space>>parseExternalCommand>>=rconst.EditExternal
+edit=char'e'>>many1space>>parseFilename>>=rconst.Edit
+writen=char'w'>>many1space>>parseFilename>>=rconst.WriteNew
+write=char'w'>>rconstWrite
+setfn=char'f'>>many1space>>parseFilename>>=rconst.SetFilename
+getfn=char'f'>>rconstGetFilename
+undo=char'u'>>rconstUndoChange
+redo=char'R'>>rconstRedoChange
+shelp=string"he">>many1space>>parseCommandName>>=rconst.HelpTopic
+help=string"he">>rconstHelpList
+inchoice(maptry[append,insert,change,delete,
+print,smallg,bigg,extedit,edit
+,writen,write,setfn,getfn,undo,
+shelp,help,redo])<|>nocomm
+
+-- | parse a CompleteCommand made of an OffsetOrRange and a Command
+parser::ParseECompleteCommand
+parser=do
+r<-parseOffsetOrRange
+c<-parseCommand>>=($r)
+return$CCc$caserof
+ORN->defaultORc
+_->r
+
+-- | the parser from a String to either a String representing an error or a CompleteCommand
+parse::String->EitherStringCompleteCommand
+parses=either(Left.show)Right$Text.ParserCombinators.Parsec.parseparser"Command Parser"s
+
+
+
{-# LANGUAGE MultiParamTypeClasses,TypeSynonymInstances,UndecidableInstances,FlexibleContexts,FlexibleInstances #-}
+-- | some framework to test Editor m w functions, providing a non IO-stacked monad m
+moduleTestwhere
+importControl.Monad.State
+importControl.Monad.Reader
+importControl.Monad.Error
+
+importControl.Monad.Writer
+
+importBuffer
+importEditor
+importEval
+importParser
+importEngine
+importUndo
+-- ErrorT String m String
+
+dataConsole=Console{cinput::[MaybeString],coutput::[String]}
+
+typeWESC=WriterT[String](StateConsole)
+instanceSIOWESCwhere
+inputSio=predefinedInput
+outputSio=normalOutput
+historySio=ignoreSio
+errorSIO=logerrors
+readfileSio=readfile
+writefileSio=writefile
+externalSio=\_->(ErrorT.return)(Right"")
+commandhelpSIO=return"command.txt"
+
+ignoreSio=const$return()::a->WESC()
+predefinedInput=const$get>>=\(Consoleio)->put(Console(taili)o)>>return(headi)
+normalOutputs=get>>=\(Consoleio)->put$Consolei(s:o)
+logerrorss=tell[s]
+readfile::String->ErrorTStringWESCString
+readfile_=return" "
+writefile__=return()
+
+
+-- | Testing a console function leaving out file IO
+commandTest
+::Test-- ^ test to be executed
+->Either[String]Bool-- ^ Left on errors, Right with the test
+commandTest(TestclineinputtextIntextOut)=let
+instate=Stato(listIntextIn)""NothingNothingNothing
+checkstate=Console(mapJustinput++[Nothing])[]
+check=either(throwError.ParserErr)eval(parsecline)::EditorWESCInsideAppend()
+done=runcheckinstate
+(result,errors)=evalState(runWriterTdone)checkstate
+inifnullerrorsthenRight((listOut.file)result==JusttextOut)elseLefterrors
+
+-- | valid data for testing
+dataTest=Test{
+commandT::String,-- ^ The command to test
+inputT::[String],-- ^ What will be eventually read as input
+startT::[String],-- ^ The file as a list of line
+endT::[String]-- ^ The modified file
+}
+
+[prima,seconda,terza]=lines"prima\nseconda\nterza"
+
+test=Test"$a"[prima][seconda][seconda,prima]
+
+
{-# LANGUAGE NoMonomorphismRestriction,MultiParamTypeClasses,FlexibleContexts,
+ FlexibleInstances,GeneralizedNewtypeDeriving,UndecidableInstances #-}
+-- | This code has been taken from <http://haskell.org>
+-- A Monad transformer UndoT on a state supporting undo , redo and hput to push the last state on history.
+-- Redo stack is blanked on hput
+moduleUndowhere
+
+importControl.Monad.State
+
+-- | State stacks wrapping states in time
+dataHistorys=History{
+current::s,-- ^ last state putted
+undos::[s],-- ^ the history of putted states (reversed) without the redos
+redos::[s]-- ^ history of the undo
+}derivingShow
+
+-- | a state monad transformer with the state history
+typeHStateTsm=StateT(Historys)m
+
+-- | facility to write signatures context
+class(Monadm,MonadState(Historys)(HStateTsm))=>HCtxms
+instance(Monadm,MonadState(Historys)(HStateTsm))=>HCtxms
+-- | a wrapper around HStateT to derive his classes and add an instance
+newtypeMonadm=>UndoTsma=UndoT(HStateTsma)deriving(Functor,Monad,MonadTrans,MonadIO)
+
+-- | the MonadState instance for the wrapper
+instance(Monadm)=>MonadStates(UndoTsm)where
+get=UndoT$getscurrent
+putx=UndoT$get>>=\(History_usrs)->put$Historyxusrs
+
+-- | tries to get back one step the state
+undo::HCtxms
+=>UndoTsmBool-- ^ False if the undo stack was empty
+undo=UndoT$do
+Historycusrs<-get
+ifnullusthenreturnFalse
+elseput(History(headus)(tailus)(c:rs))>>returnTrue
+-- | tries to get back the undo operation
+redo::HCtxms
+=>UndoTsmBool-- ^ False if the redo stack was empty
+redo=UndoT$do
+Historycusrs<-get
+ifnullrsthenreturnFalse
+elseput(History(headrs)(c:us)(tailrs))>>returnTrue
+
+-- | push the old state in the undo stack and set the new state (alternative to put)
+hput::HCtxms
+=>s-- ^ the new state to put
+->UndoTsm()-- ^ monading
+hputx=UndoT$do
+Historycundosredos<-get
+put(Historyx(c:undos)[])
+
+-- | an History of one state
+blank::s->Historys
+blanks=Historys[][]
+
+-- | run the UndoT monad transformer spitting out the computation result in the inner monad
+evalUndoT::(Monadm)
+=>UndoTsma-- ^ a UndoT action
+->s-- ^ the initial state
+->ma-- ^ the result
+evalUndoT(UndoTx)s=evalStateTx(blanks)
+
+-- | run the UndoT monad transformer spitting out the final state in the inner monad
+execUndoT::(Monadm)
+=>UndoTsma-- ^ a UndoT action
+->s-- ^ the initial state
+->ms-- ^ the final state
+execUndoT(UndoTx)s=liftMcurrent$execStateTx(blanks)
+
+