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

-> IO ByteString

Resulting 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.

runUserEditorDWIM templ initialContents = userEditorDefault _default_editor >>= theEditor ->
                                            runSpecificEditor theEditor templ initialContents

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

This is likely the simplest function here. It opens up the user's editor, and fetches a ByteString from it

runUserEditor = userEditorDefault _default_editor >>= theEditor ->
                  runSpecificEditor theEditor plainTemplate mempty

runUserEditorWithTemplate

Arguments

:: Template

Template for the file name

-> IO ByteString

Resulting ByteString

This is probably the second-simplest function.

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.

runSpecific editorName templ initialContents =
  withSystemTempFile templ $ filePath hdl -> do
    hSetBinaryMode hdl True
    hSetBuffering hdl NoBuffering
    B.hPut hdl initialContents
    callProcess editorName [filePath]
    B.hGetContents hdl

userEditor :: IO (Maybe String)

This uses getEnv from System.Posix to attempt to get the user's $EDITOR variable.

userEditor = getEnv _editor

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 -> pure e Nothing -> pure def

_default_editor :: String

The default editor if no other editor is found

_default_editor = "nano"

_editor :: String

The variable we should search when finding the user's editor.

_editor = EDITOR

_ftempl :: String

The standard filename template

_ftempl = "tmp"