Yi.Buffer.Misc

The Buffer module defines monadic editing operations over one-dimensional buffers, maintaining a current point.

Documentation

data FBuffer

Constructors

forall syntax . FBuffer !(Mode syntax) !(BufferImpl syntax) !Attributes

Instances

Eq FBuffer

Show FBuffer

Binary FBuffer

Typeable * FBuffer

MonadState FBuffer BufferM

newtype BufferM a

The BufferM monad writes the updates performed.

Constructors

BufferM

Fields

fromBufferM :: RWS Window [Update] FBuffer a

Instances

Monad BufferM

Functor BufferM

Applicative BufferM

MonadReader Window BufferM

MonadState FBuffer BufferM

MonadWriter [Update] BufferM

YiAction (BufferM x) x

MkSnippetCmd (SnippetCmd a) a

Typeable (* -> *) BufferM

type WinMarks = MarkSet Mark

data MarkSet a

Constructors

MarkSet

Fields

fromMark :: !a

insMark :: !a

selMark :: !a

Instances

Functor MarkSet

Foldable MarkSet

Traversable MarkSet

Binary a => Binary (MarkSet a)

bkey :: FBuffer -> BufferRef

getMarks :: Window -> BufferM (Maybe WinMarks)

runBuffer :: Window -> FBuffer -> BufferM a -> (a, FBuffer)

Execute a BufferM value on a given buffer and window. The new state of the buffer is returned alongside the result of the computation.

runBufferFull :: Window -> FBuffer -> BufferM a -> (a, [Update], FBuffer)

runBufferDummyWindow :: FBuffer -> BufferM a -> a

Execute a BufferM value on a given buffer, using a dummy window. The new state of the buffer is discarded.

curLn :: BufferM Int

Return the current line number

curCol :: BufferM Int

Current column. Note that this is different from offset or number of chars from sol. (This takes into account tabs, unicode chars, etc.)

colOf :: Point -> BufferM Int

lineOf :: Point -> BufferM Int

lineCountB :: BufferM Int

sizeB :: BufferM Point

Point of eof

pointB :: BufferM Point

Extract the current point

pointOfLineColB :: Int -> Int -> BufferM Point

solPointB :: Point -> BufferM Point

Returns start of line point for a given point p

eolPointB :: Point -> BufferM Point

Returns end of line for given point.

markLines :: BufferM (MarkSet Int)

Return line numbers of marks

moveTo :: Point -> BufferM ()

Move point in buffer to the given index

moveToColB :: Int -> BufferM ()

moveToLineColB :: Int -> Int -> BufferM ()

lineMoveRel :: Int -> BufferM Int

Move point down by n lines. n can be negative. Returns the actual difference in lines which we moved which may be negative if the requested line difference is negative.

lineUp :: BufferM ()

Move point up one line

lineDown :: BufferM ()

Move point down one line

newB :: BufferRef -> BufferId -> YiString -> FBuffer

Create buffer named nm with contents s

data MarkValue

Constructors

MarkValue

Fields

markPoint :: !Point

markGravity :: !Direction

Instances

Eq MarkValue

Ord MarkValue

Show MarkValue

Generic MarkValue

Binary MarkValue

Typeable * MarkValue

type Rep MarkValue

data Overlay

Instances

Eq Overlay

Ord Overlay

mkOverlay :: YiString -> Region -> StyleName -> YiString -> Overlay

Create an "overlay" for the style sty between points s and e

gotoLn :: Int -> BufferM Int

Go to line number n. n is indexed from 1. Returns the actual line we went to (which may be not be the requested line, if it was out of range)

gotoLnFrom :: Int -> BufferM Int

Go to line indexed from current point Returns the actual moved difference which of course may be negative if the requested difference was negative.

leftB :: BufferM ()

Move point -1

rightB :: BufferM ()

Move cursor +1

moveN :: Int -> BufferM ()

Move point by the given number of characters. A negative offset moves backwards a positive one forward.

leftN :: Int -> BufferM ()

Move cursor -n

rightN :: Int -> BufferM ()

Move cursor +n

insertN :: YiString -> BufferM ()

Insert the YiString at current point, extending size of buffer

insertNAt :: YiString -> Point -> BufferM ()

Insert given YiString at specified point, extending size of the buffer.

insertB :: Char -> BufferM ()

Insert the char at current point, extending size of buffer

Implementation note: This just insertBs a singleton. This seems sub-optimal because we should be able to do much better without spewing chunks of size 1 everywhere. This approach is necessary however so an Update can be recorded. A possible improvement for space would be to have ‘yi-rope’ package optimise for appends with length 1.

deleteN :: Int -> BufferM ()

Delete n characters forward from the current point

nelemsB :: Int -> Point -> BufferM YiString

writeB :: Char -> BufferM ()

Write an element into the buffer at the current point.

writeN :: YiString -> BufferM ()

Write the list into the buffer at current point.

newlineB :: BufferM ()

Insert newline at current point.

deleteNAt :: Direction -> Int -> Point -> BufferM ()

deleteNAt n p deletes n characters forwards from position p

readB :: BufferM Char

Read the character at the current point

elemsB :: BufferM YiString

Return the contents of the buffer.

undosA :: HasAttributes c => Lens' c URList

undoB :: BufferM ()

redoB :: BufferM ()

getMarkB :: Maybe String -> BufferM Mark

setMarkHereB :: BufferM Mark

setNamedMarkHereB :: String -> BufferM ()

mayGetMarkB :: String -> BufferM (Maybe Mark)

getMarkValueB :: Mark -> BufferM MarkValue

markPointA :: Mark -> Lens' FBuffer Point

modifyMarkB :: Mark -> (MarkValue -> MarkValue) -> BufferM ()

newMarkB :: MarkValue -> BufferM Mark

deleteMarkB :: Mark -> BufferM ()

setVisibleSelection :: Bool -> BufferM ()

Highlight the selection

isUnchangedBuffer :: FBuffer -> Bool

setAnyMode :: AnyMode -> BufferM ()

Set the mode

setMode :: Mode syntax -> BufferM ()

setMode0 :: forall syntax. Mode syntax -> FBuffer -> FBuffer

modifyMode :: (forall syntax. Mode syntax -> Mode syntax) -> BufferM ()

Modify the mode

regexRegionB :: SearchExp -> Region -> BufferM [Region]

Return indices of strings in buffer matched by regex in the given region.

regexB :: Direction -> SearchExp -> BufferM [Region]

Return indices of next string in buffer matched by regex in the given direction

readAtB :: Point -> BufferM Char

Read the character at the given index This is an unsafe operation: character NUL is returned when out of bounds

getModeLine :: [Text] -> BufferM Text

Given a buffer, and some information update the modeline

N.B. the contents of modelines should be specified by user, and not hardcoded.

getPercent :: Point -> Point -> Text

Given a point, and the file size, gives us a percent string

setInserting :: Bool -> BufferM ()

savingPrefCol :: BufferM a -> BufferM a

forgetPreferCol :: BufferM ()

movingToPrefCol :: BufferM a -> BufferM a

movingToPrefVisCol :: BufferM a -> BufferM a

Moves to a visual column within the current line as shown on the editor (ie, moving within the current width of a single visual line)

preferColA :: HasAttributes c => Lens' c (Maybe Int)

markSavedB :: UTCTime -> BufferM ()

Mark the current point in the undo list as a saved state.

retroactivelyAtSavePointB :: BufferM a -> BufferM a

Undo all updates that happened since last save, perform a given action and redo all updates again. Given action must not modify undo history.

addOverlayB :: Overlay -> BufferM ()

Adds an "overlay" to the buffer

delOverlayB :: Overlay -> BufferM ()

Remove an existing "overlay"

delOverlaysOfOwnerB :: YiString -> BufferM ()

getOverlaysOfOwnerB :: YiString -> BufferM (Set Overlay)

isPointInsideOverlay :: Point -> Overlay -> Bool

savingExcursionB :: BufferM a -> BufferM a

perform a BufferM a, and return to the current point. (by using a mark)

savingPointB :: BufferM a -> BufferM a

Perform an BufferM a, and return to the current point.

savingPositionB :: BufferM a -> BufferM a

Perform an BufferM a, and return to the current line and column number. The difference between this and savingPointB is that here we attempt to return to the specific line and column number, rather than a specific number of characters from the beginning of the buffer.

In case the column is further away than EOL, the point is left at EOL: moveToLineColB is used internally.

pendingUpdatesA :: HasAttributes c => Lens' c [UIUpdate]

highlightSelectionA :: Lens' FBuffer Bool

rectangleSelectionA :: Lens' FBuffer Bool

readOnlyA :: HasAttributes c => Lens' c Bool

insertingA :: HasAttributes c => Lens' c Bool

pointFollowsWindowA :: HasAttributes c => Lens' c (WindowRef -> Bool)

revertPendingUpdatesB :: BufferM ()

Revert all the pending updates; don't touch the point.

askWindow :: (Window -> a) -> BufferM a

clearSyntax :: FBuffer -> FBuffer

update the syntax information (clear the dirty "flag")

focusSyntax :: Map WindowRef Region -> FBuffer -> FBuffer

data Mode syntax

A Mode customizes the Yi interface for editing a particular data format. It specifies when the mode should be used and controls file-specific syntax highlighting and command input, among other things.

Constructors

Mode

Fields

modeName :: Text

so this can be serialized, debugged.

modeApplies :: FilePath -> YiString -> Bool

What type of files does this mode apply to?

modeHL :: ExtHL syntax

Syntax highlighter

modePrettify :: syntax -> BufferM ()

Prettify current "paragraph"

modeKeymap :: KeymapSet -> KeymapSet

Buffer-local keymap modification

modeIndent :: syntax -> IndentBehaviour -> BufferM ()

emacs-style auto-indent line

modeAdjustBlock :: syntax -> Int -> BufferM ()

adjust the indentation after modification

modeFollow :: syntax -> Action

Follow a "link" in the file. (eg. go to location of error message)

modeIndentSettings :: IndentSettings

modeToggleCommentSelection :: Maybe (BufferM ())

modeGetStrokes :: syntax -> Point -> Point -> Point -> [Stroke]

Strokes that should be applied when displaying a syntax element should this be an Action instead?

modeOnLoad :: BufferM ()

An action that is to be executed when this mode is set

modeModeLine :: [Text] -> BufferM Text

buffer-local modeline formatting method

modeGotoDeclaration :: BufferM ()

go to the point where the variable is declared

Instances

Binary (Mode syntax)

Just stores the mode name.

modeNameA :: forall syntax. Lens' (Mode syntax) Text

modeAppliesA :: forall syntax. Lens' (Mode syntax) (FilePath -> YiString -> Bool)

modeHLA :: forall syntax. Lens' (Mode syntax) (ExtHL syntax)

modePrettifyA :: forall syntax. Lens' (Mode syntax) (syntax -> BufferM ())

modeKeymapA :: forall syntax. Lens' (Mode syntax) (KeymapSet -> KeymapSet)

modeIndentA :: forall syntax. Lens' (Mode syntax) (syntax -> IndentBehaviour -> BufferM ())

modeAdjustBlockA :: forall syntax. Lens' (Mode syntax) (syntax -> Int -> BufferM ())

modeFollowA :: forall syntax. Lens' (Mode syntax) (syntax -> Action)

modeIndentSettingsA :: forall syntax. Lens' (Mode syntax) IndentSettings

modeToggleCommentSelectionA :: forall syntax. Lens' (Mode syntax) (Maybe (BufferM ()))

modeGetStrokesA :: forall syntax. Lens' (Mode syntax) (syntax -> Point -> Point -> Point -> [Stroke])

modeOnLoadA :: forall syntax. Lens' (Mode syntax) (BufferM ())

modeModeLineA :: forall syntax. Lens' (Mode syntax) ([Text] -> BufferM Text)

data AnyMode

Constructors

forall syntax . AnyMode (Mode syntax)

Instances

Typeable * AnyMode

data IndentBehaviour

Used to specify the behaviour of the automatic indent command.

Constructors

IncreaseCycle

Increase the indentation to the next higher indentation hint. If we are currently at the highest level of indentation then cycle back to the lowest.

DecreaseCycle

Decrease the indentation to the next smaller indentation hint. If we are currently at the smallest level then cycle back to the largest

IncreaseOnly

Increase the indentation to the next higher hint if no such hint exists do nothing.

DecreaseOnly

Decrease the indentation to the next smaller indentation hint, if no such hint exists do nothing.

Instances

Eq IndentBehaviour

Show IndentBehaviour

data IndentSettings

Currently duplicates some of Vim's indent settings. Allowing a buffer to specify settings that are more dynamic, perhaps via closures, could be useful.

Constructors

IndentSettings

Fields

expandTabs :: Bool

Insert spaces instead of tabs as possible

tabSize :: Int

Size of a Tab

shiftWidth :: Int

Indent by so many columns

Instances

Eq IndentSettings

Show IndentSettings

Typeable * IndentSettings

expandTabsA :: Lens' IndentSettings Bool

tabSizeA :: Lens' IndentSettings Int

shiftWidthA :: Lens' IndentSettings Int

modeAlwaysApplies :: a -> b -> Bool

Mode applies function that always returns True.

modeNeverApplies :: a -> b -> Bool

Mode applies function that always returns False.

emptyMode :: Mode syntax

withModeB :: (forall syntax. Mode syntax -> BufferM a) -> BufferM a

withMode0 :: (forall syntax. Mode syntax -> a) -> FBuffer -> a

onMode :: (forall syntax. Mode syntax -> Mode syntax) -> AnyMode -> AnyMode

withSyntaxB :: (forall syntax. Mode syntax -> syntax -> a) -> BufferM a

withSyntaxB' :: (forall syntax. Mode syntax -> syntax -> BufferM a) -> BufferM a

keymapProcessA :: HasAttributes c => Lens' c KeymapProcess

strokesRangesB :: Maybe SearchExp -> Region -> BufferM [[Stroke]]

streamB :: Direction -> Point -> BufferM YiString

indexedStreamB :: Direction -> Point -> BufferM [(Point, Char)]

askMarks :: BufferM WinMarks

pointAt :: BufferM a -> BufferM Point

data SearchExp :: *

Instances

Binary SearchExp

lastActiveWindowA :: HasAttributes c => Lens' c Window

putBufferDyn :: (YiVariable a, MonadState FBuffer m, Functor m) => a -> m ()

Access to a value into the extensible state, keyed by its type. This allows you to save inside a BufferM monad, ie:

putBufferDyn updatedvalue

getBufferDyn :: (YiVariable a, MonadState FBuffer m, Functor m) => m a

Access to a value into the extensible state, keyed by its type. This allows you to retrieve inside a BufferM monad, ie:

value <- getBufferDyn

shortIdentString

Arguments

:: Int

Number of characters to drop from FileBuffer names

-> FBuffer

Buffer to work with

-> Text

Gets a short identifier of a buffer. If we're given a MemBuffer then just wraps the buffer name like so: *name*. If we're given a FileBuffer, it drops the the number of characters specified.

>>> shortIdentString 3 (MemBuffer "hello")
"*hello*"
>>> shortIdentString 3 (FileBuffer "hello")
"lo"

identString :: FBuffer -> Text

Gets the buffer's identifier string, emphasising the MemBuffer:

>>> identString (MemBuffer "hello")
"*hello*"
>>> identString (FileBuffer "hello")
"hello"

miniIdentString :: FBuffer -> Text

identA :: HasAttributes c => Lens' c BufferId

directoryContentA :: HasAttributes c => Lens' c Bool

data BufferId

Constructors

MemBuffer Text

FileBuffer FilePath

Instances

Eq BufferId

Ord BufferId

Show BufferId

Binary BufferId

file :: FBuffer -> Maybe FilePath

lastSyncTimeA :: HasAttributes c => Lens' c UTCTime

replaceCharB :: Char -> BufferM ()

replaceCharWithBelowB :: BufferM ()

replaceCharWithAboveB :: BufferM ()

insertCharWithBelowB :: BufferM ()

insertCharWithAboveB :: BufferM ()

pointAfterCursorB :: Point -> BufferM Point

destinationOfMoveB :: BufferM a -> BufferM Point

What would be the point after doing the given action? The argument must not modify the buffer.

withEveryLineB :: BufferM () -> BufferM ()

startUpdateTransactionB :: BufferM ()

commitUpdateTransactionB :: BufferM ()

applyUpdate :: Update -> BufferM ()

betweenB

Arguments

:: Point

Point to start at

-> Point

Point to stop at

-> BufferM YiString

Returns the contents of the buffer between the two points.

If the startPoint >= endPoint, empty string is returned. If the points are out of bounds, as much of the content as possible is taken: you're not guaranteed to get endPoint - startPoint characters.

decreaseFontSize :: Int -> BufferM ()

Decreases the font size in the buffer by specified number. What this number actually means depends on the front-end.

increaseFontSize :: Int -> BufferM ()

Increases the font size in the buffer by specified number. What this number actually means depends on the front-end.

indentSettingsB :: BufferM IndentSettings

Gives the IndentSettings for the current buffer.

fontsizeVariationA :: HasAttributes c => Lens' c Int

encodingConverterNameA :: HasAttributes c => Lens' c (Maybe ConverterName)