Text.Editor

You know when you run git commit, and a little editor pops up? This is a Haskell library that does that.

Documentation

runUserEditorDWIM

Arguments

:: Template

Template for the file name

-> ByteString

Initial contents (strict ByteString)

-> IO ByteString

Resulting (strict) ByteString

This is most likely the function you want to use. It takes a file type template as an argument, along with what you want displayed when the user opens the editor. It then runs the editor, and returns the version of the text that the user modified.

Examples:

>>> :set -XOverloadedStrings
>>> runUserEditorDWIM jsonTemplate "{\n\n}\n"

This will open up the user's $EDITOR configured to edit JSON, and with the initial text:

{
}

There are a bunch of templates. See the "File-type extensions" section. It's also trivially easy to make your own templates. Say you want one for, I dunno, Python:

pythonTemplate = mkTemplate "py"

The argument to mkTemplate should be the file extension you want. In that case, I used "py", because Python's file extension is .py.

runUserEditorDWIMFile

Arguments

:: Template

Template for the file name

-> FilePath

File containing initial contents

-> IO ByteString

Resulting ByteString

This is the same as above, it just takes a file as an argument instead of the ByteString

runUserEditorDWIMFile templ fp = B.readFile fp >>=  runUserEditorDWIM templ

runUserEditor :: IO ByteString

Open up the user's editor with no initial contents.

runUserEditorWithTemplate

Arguments

:: Template

Template for the file name

-> IO ByteString

Resulting ByteString

This is probably the second-simplest function.

bracketConduit :: Template -> Producer (ResourceT IO) ByteString -> Consumer ByteString (ResourceT IO) b -> ResourceT IO b

type Template = String

mkTemplate :: String -> Template

Make a template

mkTemplate ext = _ftempl <> "." <> ext

>>> mkTemplate "blah"
tmp.blah

htmlTemplate :: Template

File-type template for HTML

htmlTemplate = mkTemplate "html"

jsonTemplate :: Template

File-type template for JSON

jsonTemplate = mkTemplate "json"

markdownTemplate :: Template

File-type template for Markdown

markdownTemplate = mkTemplate "md"

oldMarkdownTemplate :: Template

Older file-type template for Markdown

markdownTemplate = mkTemplate "markdown"

plainTemplate :: Template

File-type template for plain text

plainTemplate = mkTemplate "txt"

xmlTemplate :: Template

File-type template for XML

xmlTemplate = mkTemplate "xml"

txtTemplate :: Template

Same as plainTemplate

yamlTemplate :: Template

File-type template for YAML

yamlTemplate = mkTemplate "yaml"

runSpecificEditor

Arguments

:: String

Name of the editor.

-> Template

Template for the file name.

-> ByteString

Initial contents of the file.

-> IO ByteString

Resulting ByteString.

Open an editor. You probably don't want to use this function.

userEditor :: IO (Maybe String)

This uses getEnv from System.Posix to attempt to get the user's $EDITOR variable. Failing that, try the $VISUAL variable.

userEditorDefault

Arguments

:: String

Default value if $EDITOR is not found.

-> IO String

Wrapper around userEditor that includes a fallback option if the $EDITOR variable doesn't exist. userEditorDefault def = userEditor >>= case Just e -> return e Nothing -> return def

_default_editor :: String

The default editor if no other editor is found

_default_editor = "vi"

_editors :: [String]

The list of variables we should search when finding the user's editor.

_editor = ["EDITOR", "VISUAL"]

Since: 0.6.0.0

_ftempl :: String

The standard filename template

_ftempl = "tmp"

wrapStr :: ByteString -> String

If you don't want to use ByteString, use this function.

>>> :type runUserEditorDWIM plainTemplate mempty
IO ByteString
>>> :type fmap wrapStr (runUserEditorDWIM plainTemplate mempty)
IO String